@midnight-ntwrk/credential-compact 0.2.0-rc2 → 0.3.0-rc1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +11 -2
- package/README.md +19 -1
- package/dist/compact-build.json +2 -2
- package/dist/credentials/signer-authorization.compact +5 -0
- package/dist/credentials/vc.compact +6 -0
- package/dist/credentials/vp.compact +46 -0
- package/dist/managed/credentials/contract/index.js +14 -14
- package/dist/managed/credentials/contract/index.js.map +1 -1
- package/package.json +1 -1
package/CHANGELOG.md
CHANGED
|
@@ -1,6 +1,15 @@
|
|
|
1
1
|
# Changelog
|
|
2
2
|
|
|
3
|
-
##
|
|
3
|
+
## Unreleased
|
|
4
|
+
|
|
5
|
+
- Add the supported explicit-holder presentation-proof composition, including
|
|
6
|
+
credential-to-presentation holder equality, signer-reference and accepted-key
|
|
7
|
+
binding, internally derived body-root verification, and substitution-negative
|
|
8
|
+
conformance.
|
|
9
|
+
- Require every normative non-codec operation to map back to a supported core
|
|
10
|
+
or extension Compact circuit.
|
|
11
|
+
|
|
12
|
+
## 0.2.0 - 2026-09-25
|
|
4
13
|
|
|
5
14
|
- Classified every exported Compact circuit and added fail-closed coverage for
|
|
6
15
|
envelope invariants, verification-method references, proof contexts, and
|
|
@@ -14,7 +23,7 @@
|
|
|
14
23
|
exact method/key/scope binding circuits, monotonic lifecycle validation, and
|
|
15
24
|
domain-separated Jubjub authority and verifier-request proof contexts without
|
|
16
25
|
introducing Trust Registry or datetime dependencies.
|
|
17
|
-
- Documented `midnight-did` `0.
|
|
26
|
+
- Documented `midnight-did` `0.7.0` as the current downstream adapter
|
|
18
27
|
compatibility baseline while keeping the Compact package DID-independent.
|
|
19
28
|
- Bound authority decisions to an explicit consumer/network domain, made
|
|
20
29
|
revocation terminal per authorization ID, validated Jubjub subgroup
|
package/README.md
CHANGED
|
@@ -4,7 +4,7 @@
|
|
|
4
4
|
> Maturity: `core`
|
|
5
5
|
> Package class: `dist`
|
|
6
6
|
|
|
7
|
-
Supported
|
|
7
|
+
Supported pre-1.0 package for reusable, family-neutral Compact VC/VP
|
|
8
8
|
semantics. This is a library include surface, not a deployable contract,
|
|
9
9
|
credential family, proof artifact, or registry authority.
|
|
10
10
|
|
|
@@ -25,12 +25,30 @@ domain-separated challenges, and verify Schnorr signatures. Signed timestamps
|
|
|
25
25
|
and challenge hashes still require application-defined time, freshness,
|
|
26
26
|
audience, and replay policy.
|
|
27
27
|
|
|
28
|
+
`ExplicitHolderPresentationProof<TPublicClaims, TClaimCommitments,
|
|
29
|
+
TDisclosures, TStatusBinding>::assertValidPresentationProof` is the supported
|
|
30
|
+
presentation-proof entrypoint. It accepts the credential, an independently
|
|
31
|
+
accepted holder public key, the complete presentation, and its proof; derives
|
|
32
|
+
the presentation root internally; validates generic VC-to-VP relations; rejects
|
|
33
|
+
holder or proof-key mismatch; binds the proof signer reference and key; and
|
|
34
|
+
verifies the presentation-context signature. The accepted key is a trust input:
|
|
35
|
+
the circuit cannot distinguish a pinned or authorized method snapshot from an
|
|
36
|
+
internally consistent attacker-supplied snapshot. Consumers still apply
|
|
37
|
+
credential-proof verification, DID resolution or snapshot authentication,
|
|
38
|
+
family-specific disclosure relations, status, freshness, and application policy
|
|
39
|
+
separately.
|
|
40
|
+
|
|
28
41
|
Signer authorization supports two composition modes. Applications may install
|
|
29
42
|
an accepted descriptor through local governance, or verify a domain-separated
|
|
30
43
|
authority proof before materializing the same descriptor. The authorization
|
|
31
44
|
proof is bound to a caller-configured network/consumer domain. The composed
|
|
32
45
|
`VC<>::assertAuthorizedIssuerProof` and verifier-request helper verify the
|
|
33
46
|
signature as well as the exact role, method, key, and scope binding. This
|
|
47
|
+
composed issuer helper is the supported authorization-aware issuance path.
|
|
48
|
+
`assertAuthorizedIssuerDescriptor` and
|
|
49
|
+
`assertProofSignerMatchesAuthorization` are low-level metadata comparisons and
|
|
50
|
+
do not verify a signature. `VC<>::assertValidCredentialProof` verifies a
|
|
51
|
+
credential's self-declared issuer proof but does not authorize that issuer. This
|
|
34
52
|
package does not resolve
|
|
35
53
|
`midnight-did`, evaluate Trust Registry policy, synchronize registry state, or
|
|
36
54
|
provide trusted wall-clock time.
|
package/dist/compact-build.json
CHANGED
|
@@ -5,8 +5,8 @@
|
|
|
5
5
|
"name": "@midnight-ntwrk/compact-runtime",
|
|
6
6
|
"version": "0.16.0"
|
|
7
7
|
},
|
|
8
|
-
"sourceDigest": "
|
|
9
|
-
"artifactDigest": "
|
|
8
|
+
"sourceDigest": "3a2e6360bfce9c9d182bee43b852347ae5ec3395c5e2ec0726a39b3c137d03dd",
|
|
9
|
+
"artifactDigest": "9615f24e1497d911225fb6452afdcddfccf152923634ec1d71c704e7108c2cf4",
|
|
10
10
|
"sourceFiles": [
|
|
11
11
|
"src/credentials/composable.compact",
|
|
12
12
|
"src/credentials/holder-bindings.compact",
|
|
@@ -105,6 +105,8 @@ export pure circuit assertProofSignerMatchesAuthorization(
|
|
|
105
105
|
proof: Proof,
|
|
106
106
|
descriptor: AuthorizedSignerDescriptor
|
|
107
107
|
): [] {
|
|
108
|
+
// Low-level metadata binding only. This circuit does not verify proof.signature.
|
|
109
|
+
// Authorization-aware consumers must use a context-specific composed helper.
|
|
108
110
|
assertValidAuthorizedSignerDescriptor(descriptor);
|
|
109
111
|
assert(
|
|
110
112
|
descriptor.state == AuthorizationState.active,
|
|
@@ -131,6 +133,9 @@ export pure circuit assertAuthorizedIssuerDescriptor(
|
|
|
131
133
|
proof: Proof,
|
|
132
134
|
descriptor: AuthorizedSignerDescriptor
|
|
133
135
|
): [] {
|
|
136
|
+
// Low-level descriptor/scope binding only. A forged signature can satisfy
|
|
137
|
+
// these comparisons; VC<>::assertAuthorizedIssuerProof is the supported
|
|
138
|
+
// issuer-authorization decision circuit.
|
|
134
139
|
assertProofSignerMatchesAuthorization(proof, descriptor);
|
|
135
140
|
assert(
|
|
136
141
|
descriptor.role == SignerRole.issuer,
|
|
@@ -37,6 +37,8 @@ module VC<TPublicClaims, TClaimCommitments, THolderBinding, TStatusBinding> {
|
|
|
37
37
|
credential: Credential,
|
|
38
38
|
proof: Proof
|
|
39
39
|
): [] {
|
|
40
|
+
// Cryptographic validity only: the credential names its own issuer method.
|
|
41
|
+
// Use assertAuthorizedIssuerProof for an issuer-authorization decision.
|
|
40
42
|
const bodyRoot: Bytes<32> = credentialBodyRoot(credential);
|
|
41
43
|
assertValidCredentialProofForCanonicalBodyRoot(credential, proof, bodyRoot);
|
|
42
44
|
}
|
|
@@ -46,6 +48,8 @@ module VC<TPublicClaims, TClaimCommitments, THolderBinding, TStatusBinding> {
|
|
|
46
48
|
proof: Proof,
|
|
47
49
|
bodyRoot: Bytes<32>
|
|
48
50
|
): [] {
|
|
51
|
+
// Cryptographic validity only. The caller-supplied root is checked against
|
|
52
|
+
// the credential, but no signer authorization is applied here.
|
|
49
53
|
assert(
|
|
50
54
|
bodyRoot == credentialBodyRoot(credential),
|
|
51
55
|
"Credential body root does not match credential"
|
|
@@ -74,6 +78,8 @@ module VC<TPublicClaims, TClaimCommitments, THolderBinding, TStatusBinding> {
|
|
|
74
78
|
proof: Proof,
|
|
75
79
|
descriptor: AuthorizedSignerDescriptor
|
|
76
80
|
): [] {
|
|
81
|
+
// Canonical authorization-aware issuance path: descriptor binding and the
|
|
82
|
+
// credential-derived issuance-context signature are both mandatory.
|
|
77
83
|
assertAuthorizedIssuerDescriptor(credential.schema, proof, descriptor);
|
|
78
84
|
assertValidCredentialProof(credential, proof);
|
|
79
85
|
}
|
|
@@ -23,3 +23,49 @@ module VP<TDisclosures, THolderBinding> {
|
|
|
23
23
|
assert(presentation.version == 1, "Presentation version mismatch");
|
|
24
24
|
}
|
|
25
25
|
}
|
|
26
|
+
|
|
27
|
+
// Canonical presentation-proof composition for the core's supported explicit
|
|
28
|
+
// holder profile. The credential is supplied directly so a caller cannot
|
|
29
|
+
// accidentally validate against the presentation's self-selected binding.
|
|
30
|
+
module ExplicitHolderPresentationProof<
|
|
31
|
+
TPublicClaims,
|
|
32
|
+
TClaimCommitments,
|
|
33
|
+
TDisclosures,
|
|
34
|
+
TStatusBinding
|
|
35
|
+
> {
|
|
36
|
+
import VC<
|
|
37
|
+
TPublicClaims,
|
|
38
|
+
TClaimCommitments,
|
|
39
|
+
ExplicitHolderBinding,
|
|
40
|
+
TStatusBinding
|
|
41
|
+
> prefix ExplicitHolderVC_;
|
|
42
|
+
import VP<TDisclosures, ExplicitHolderBinding> prefix ExplicitHolderVP_;
|
|
43
|
+
import CredentialPresentationRelations<
|
|
44
|
+
TPublicClaims,
|
|
45
|
+
TClaimCommitments,
|
|
46
|
+
TDisclosures,
|
|
47
|
+
ExplicitHolderBinding,
|
|
48
|
+
TStatusBinding
|
|
49
|
+
> prefix ExplicitHolderRelations_;
|
|
50
|
+
|
|
51
|
+
export pure circuit assertValidPresentationProof(
|
|
52
|
+
credential: ExplicitHolderVC_Credential,
|
|
53
|
+
acceptedHolderPublicKey: JubjubPoint,
|
|
54
|
+
presentation: ExplicitHolderVP_Presentation,
|
|
55
|
+
proof: Proof
|
|
56
|
+
): [] {
|
|
57
|
+
const bodyRoot: Bytes<32> = ExplicitHolderVP_presentationBodyRoot(presentation);
|
|
58
|
+
ExplicitHolderVP_assertValidPresentationEnvelope(presentation);
|
|
59
|
+
ExplicitHolderRelations_assertMatchingCredentialPresentation(
|
|
60
|
+
credential,
|
|
61
|
+
presentation
|
|
62
|
+
);
|
|
63
|
+
assertMatchingExplicitHolderBindings(
|
|
64
|
+
credential.holderBinding,
|
|
65
|
+
presentation.holderBinding
|
|
66
|
+
);
|
|
67
|
+
assertProofMatchesExplicitHolderBinding(presentation.holderBinding, proof);
|
|
68
|
+
assertMatchingJubjubPoints(acceptedHolderPublicKey, proof.publicKey);
|
|
69
|
+
assertValidPresentationContextProof(bodyRoot, proof);
|
|
70
|
+
}
|
|
71
|
+
}
|
|
@@ -1363,21 +1363,21 @@ export const pureCircuits = {
|
|
|
1363
1363
|
if (!(typeof(schema_0) === 'object' && schema_0.packageId.buffer instanceof ArrayBuffer && schema_0.packageId.BYTES_PER_ELEMENT === 1 && schema_0.packageId.length === 32 && schema_0.schemaId.buffer instanceof ArrayBuffer && schema_0.schemaId.BYTES_PER_ELEMENT === 1 && schema_0.schemaId.length === 32 && typeof(schema_0.majorVersion) === 'bigint' && schema_0.majorVersion >= 0n && schema_0.majorVersion <= 65535n && typeof(schema_0.minorVersion) === 'bigint' && schema_0.minorVersion >= 0n && schema_0.minorVersion <= 65535n)) {
|
|
1364
1364
|
__compactRuntime.typeError('assertAuthorizedIssuerDescriptor',
|
|
1365
1365
|
'argument 1',
|
|
1366
|
-
'signer-authorization.compact line
|
|
1366
|
+
'signer-authorization.compact line 131 char 1',
|
|
1367
1367
|
'struct SchemaRef<packageId: Bytes<32>, schemaId: Bytes<32>, majorVersion: Uint<0..65536>, minorVersion: Uint<0..65536>>',
|
|
1368
1368
|
schema_0)
|
|
1369
1369
|
}
|
|
1370
1370
|
if (!(typeof(proof_0) === 'object' && typeof(proof_0.signerVerificationMethodRef) === 'object' && typeof(proof_0.signerVerificationMethodRef.controllerAddress) === 'object' && proof_0.signerVerificationMethodRef.controllerAddress.bytes.buffer instanceof ArrayBuffer && proof_0.signerVerificationMethodRef.controllerAddress.bytes.BYTES_PER_ELEMENT === 1 && proof_0.signerVerificationMethodRef.controllerAddress.bytes.length === 32 && proof_0.signerVerificationMethodRef.methodId.buffer instanceof ArrayBuffer && proof_0.signerVerificationMethodRef.methodId.BYTES_PER_ELEMENT === 1 && proof_0.signerVerificationMethodRef.methodId.length === 32 && typeof(proof_0.createdAt) === 'bigint' && proof_0.createdAt >= 0n && proof_0.createdAt <= 18446744073709551615n && proof_0.challengeHash.buffer instanceof ArrayBuffer && proof_0.challengeHash.BYTES_PER_ELEMENT === 1 && proof_0.challengeHash.length === 32 && true && typeof(proof_0.signature) === 'object' && true && typeof(proof_0.signature.s) === 'bigint' && proof_0.signature.s >= 0 && proof_0.signature.s <= __compactRuntime.MAX_FIELD)) {
|
|
1371
1371
|
__compactRuntime.typeError('assertAuthorizedIssuerDescriptor',
|
|
1372
1372
|
'argument 2',
|
|
1373
|
-
'signer-authorization.compact line
|
|
1373
|
+
'signer-authorization.compact line 131 char 1',
|
|
1374
1374
|
'struct Proof<signerVerificationMethodRef: struct VerificationMethodRef<controllerAddress: struct ContractAddress<bytes: Bytes<32>>, methodId: Bytes<32>>, createdAt: Uint<0..18446744073709551616>, challengeHash: Bytes<32>, publicKey: Opaque<"JubjubPoint">, signature: struct Signature<r: Opaque<"JubjubPoint">, s: Field>>',
|
|
1375
1375
|
proof_0)
|
|
1376
1376
|
}
|
|
1377
1377
|
if (!(typeof(descriptor_0) === 'object' && typeof(descriptor_0.version) === 'bigint' && descriptor_0.version >= 0n && descriptor_0.version <= 65535n && descriptor_0.authorizationId.buffer instanceof ArrayBuffer && descriptor_0.authorizationId.BYTES_PER_ELEMENT === 1 && descriptor_0.authorizationId.length === 32 && typeof(descriptor_0.decisionSequence) === 'bigint' && descriptor_0.decisionSequence >= 0n && descriptor_0.decisionSequence <= 18446744073709551615n && typeof(descriptor_0.state) === 'number' && descriptor_0.state >= 0 && descriptor_0.state <= 2 && typeof(descriptor_0.role) === 'number' && descriptor_0.role >= 0 && descriptor_0.role <= 1 && typeof(descriptor_0.signerVerificationMethodRef) === 'object' && typeof(descriptor_0.signerVerificationMethodRef.controllerAddress) === 'object' && descriptor_0.signerVerificationMethodRef.controllerAddress.bytes.buffer instanceof ArrayBuffer && descriptor_0.signerVerificationMethodRef.controllerAddress.bytes.BYTES_PER_ELEMENT === 1 && descriptor_0.signerVerificationMethodRef.controllerAddress.bytes.length === 32 && descriptor_0.signerVerificationMethodRef.methodId.buffer instanceof ArrayBuffer && descriptor_0.signerVerificationMethodRef.methodId.BYTES_PER_ELEMENT === 1 && descriptor_0.signerVerificationMethodRef.methodId.length === 32 && true && typeof(descriptor_0.didStateVersion) === 'bigint' && descriptor_0.didStateVersion >= 0n && descriptor_0.didStateVersion <= 18446744073709551615n && typeof(descriptor_0.verificationRelationship) === 'number' && descriptor_0.verificationRelationship >= 0 && descriptor_0.verificationRelationship <= 2 && descriptor_0.scopeCommitment.buffer instanceof ArrayBuffer && descriptor_0.scopeCommitment.BYTES_PER_ELEMENT === 1 && descriptor_0.scopeCommitment.length === 32 && descriptor_0.policyCommitment.buffer instanceof ArrayBuffer && descriptor_0.policyCommitment.BYTES_PER_ELEMENT === 1 && descriptor_0.policyCommitment.length === 32)) {
|
|
1378
1378
|
__compactRuntime.typeError('assertAuthorizedIssuerDescriptor',
|
|
1379
1379
|
'argument 3',
|
|
1380
|
-
'signer-authorization.compact line
|
|
1380
|
+
'signer-authorization.compact line 131 char 1',
|
|
1381
1381
|
'struct AuthorizedSignerDescriptor<version: Uint<0..65536>, authorizationId: Bytes<32>, decisionSequence: Uint<0..18446744073709551616>, state: Enum<AuthorizationState, active, suspended, revoked>, role: Enum<SignerRole, issuer, verifier>, signerVerificationMethodRef: struct VerificationMethodRef<controllerAddress: struct ContractAddress<bytes: Bytes<32>>, methodId: Bytes<32>>, signerPublicKey: Opaque<"JubjubPoint">, didStateVersion: Uint<0..18446744073709551616>, verificationRelationship: Enum<VerificationRelationship, assertionMethod, authentication, capabilityInvocation>, scopeCommitment: Bytes<32>, policyCommitment: Bytes<32>>',
|
|
1382
1382
|
descriptor_0)
|
|
1383
1383
|
}
|
|
@@ -1395,21 +1395,21 @@ export const pureCircuits = {
|
|
|
1395
1395
|
if (!(requestScopeCommitment_0.buffer instanceof ArrayBuffer && requestScopeCommitment_0.BYTES_PER_ELEMENT === 1 && requestScopeCommitment_0.length === 32)) {
|
|
1396
1396
|
__compactRuntime.typeError('assertAuthorizedVerifierProof',
|
|
1397
1397
|
'argument 1',
|
|
1398
|
-
'signer-authorization.compact line
|
|
1398
|
+
'signer-authorization.compact line 150 char 1',
|
|
1399
1399
|
'Bytes<32>',
|
|
1400
1400
|
requestScopeCommitment_0)
|
|
1401
1401
|
}
|
|
1402
1402
|
if (!(typeof(proof_0) === 'object' && typeof(proof_0.signerVerificationMethodRef) === 'object' && typeof(proof_0.signerVerificationMethodRef.controllerAddress) === 'object' && proof_0.signerVerificationMethodRef.controllerAddress.bytes.buffer instanceof ArrayBuffer && proof_0.signerVerificationMethodRef.controllerAddress.bytes.BYTES_PER_ELEMENT === 1 && proof_0.signerVerificationMethodRef.controllerAddress.bytes.length === 32 && proof_0.signerVerificationMethodRef.methodId.buffer instanceof ArrayBuffer && proof_0.signerVerificationMethodRef.methodId.BYTES_PER_ELEMENT === 1 && proof_0.signerVerificationMethodRef.methodId.length === 32 && typeof(proof_0.createdAt) === 'bigint' && proof_0.createdAt >= 0n && proof_0.createdAt <= 18446744073709551615n && proof_0.challengeHash.buffer instanceof ArrayBuffer && proof_0.challengeHash.BYTES_PER_ELEMENT === 1 && proof_0.challengeHash.length === 32 && true && typeof(proof_0.signature) === 'object' && true && typeof(proof_0.signature.s) === 'bigint' && proof_0.signature.s >= 0 && proof_0.signature.s <= __compactRuntime.MAX_FIELD)) {
|
|
1403
1403
|
__compactRuntime.typeError('assertAuthorizedVerifierProof',
|
|
1404
1404
|
'argument 2',
|
|
1405
|
-
'signer-authorization.compact line
|
|
1405
|
+
'signer-authorization.compact line 150 char 1',
|
|
1406
1406
|
'struct Proof<signerVerificationMethodRef: struct VerificationMethodRef<controllerAddress: struct ContractAddress<bytes: Bytes<32>>, methodId: Bytes<32>>, createdAt: Uint<0..18446744073709551616>, challengeHash: Bytes<32>, publicKey: Opaque<"JubjubPoint">, signature: struct Signature<r: Opaque<"JubjubPoint">, s: Field>>',
|
|
1407
1407
|
proof_0)
|
|
1408
1408
|
}
|
|
1409
1409
|
if (!(typeof(descriptor_0) === 'object' && typeof(descriptor_0.version) === 'bigint' && descriptor_0.version >= 0n && descriptor_0.version <= 65535n && descriptor_0.authorizationId.buffer instanceof ArrayBuffer && descriptor_0.authorizationId.BYTES_PER_ELEMENT === 1 && descriptor_0.authorizationId.length === 32 && typeof(descriptor_0.decisionSequence) === 'bigint' && descriptor_0.decisionSequence >= 0n && descriptor_0.decisionSequence <= 18446744073709551615n && typeof(descriptor_0.state) === 'number' && descriptor_0.state >= 0 && descriptor_0.state <= 2 && typeof(descriptor_0.role) === 'number' && descriptor_0.role >= 0 && descriptor_0.role <= 1 && typeof(descriptor_0.signerVerificationMethodRef) === 'object' && typeof(descriptor_0.signerVerificationMethodRef.controllerAddress) === 'object' && descriptor_0.signerVerificationMethodRef.controllerAddress.bytes.buffer instanceof ArrayBuffer && descriptor_0.signerVerificationMethodRef.controllerAddress.bytes.BYTES_PER_ELEMENT === 1 && descriptor_0.signerVerificationMethodRef.controllerAddress.bytes.length === 32 && descriptor_0.signerVerificationMethodRef.methodId.buffer instanceof ArrayBuffer && descriptor_0.signerVerificationMethodRef.methodId.BYTES_PER_ELEMENT === 1 && descriptor_0.signerVerificationMethodRef.methodId.length === 32 && true && typeof(descriptor_0.didStateVersion) === 'bigint' && descriptor_0.didStateVersion >= 0n && descriptor_0.didStateVersion <= 18446744073709551615n && typeof(descriptor_0.verificationRelationship) === 'number' && descriptor_0.verificationRelationship >= 0 && descriptor_0.verificationRelationship <= 2 && descriptor_0.scopeCommitment.buffer instanceof ArrayBuffer && descriptor_0.scopeCommitment.BYTES_PER_ELEMENT === 1 && descriptor_0.scopeCommitment.length === 32 && descriptor_0.policyCommitment.buffer instanceof ArrayBuffer && descriptor_0.policyCommitment.BYTES_PER_ELEMENT === 1 && descriptor_0.policyCommitment.length === 32)) {
|
|
1410
1410
|
__compactRuntime.typeError('assertAuthorizedVerifierProof',
|
|
1411
1411
|
'argument 3',
|
|
1412
|
-
'signer-authorization.compact line
|
|
1412
|
+
'signer-authorization.compact line 150 char 1',
|
|
1413
1413
|
'struct AuthorizedSignerDescriptor<version: Uint<0..65536>, authorizationId: Bytes<32>, decisionSequence: Uint<0..18446744073709551616>, state: Enum<AuthorizationState, active, suspended, revoked>, role: Enum<SignerRole, issuer, verifier>, signerVerificationMethodRef: struct VerificationMethodRef<controllerAddress: struct ContractAddress<bytes: Bytes<32>>, methodId: Bytes<32>>, signerPublicKey: Opaque<"JubjubPoint">, didStateVersion: Uint<0..18446744073709551616>, verificationRelationship: Enum<VerificationRelationship, assertionMethod, authentication, capabilityInvocation>, scopeCommitment: Bytes<32>, policyCommitment: Bytes<32>>',
|
|
1414
1414
|
descriptor_0)
|
|
1415
1415
|
}
|
|
@@ -1425,7 +1425,7 @@ export const pureCircuits = {
|
|
|
1425
1425
|
if (!(typeof(authority_0) === 'object' && authority_0.domainCommitment.buffer instanceof ArrayBuffer && authority_0.domainCommitment.BYTES_PER_ELEMENT === 1 && authority_0.domainCommitment.length === 32 && typeof(authority_0.verificationMethodRef) === 'object' && typeof(authority_0.verificationMethodRef.controllerAddress) === 'object' && authority_0.verificationMethodRef.controllerAddress.bytes.buffer instanceof ArrayBuffer && authority_0.verificationMethodRef.controllerAddress.bytes.BYTES_PER_ELEMENT === 1 && authority_0.verificationMethodRef.controllerAddress.bytes.length === 32 && authority_0.verificationMethodRef.methodId.buffer instanceof ArrayBuffer && authority_0.verificationMethodRef.methodId.BYTES_PER_ELEMENT === 1 && authority_0.verificationMethodRef.methodId.length === 32 && true)) {
|
|
1426
1426
|
__compactRuntime.typeError('assertValidSignerAuthorizationAuthority',
|
|
1427
1427
|
'argument 1',
|
|
1428
|
-
'signer-authorization.compact line
|
|
1428
|
+
'signer-authorization.compact line 171 char 1',
|
|
1429
1429
|
'struct SignerAuthorizationAuthority<domainCommitment: Bytes<32>, verificationMethodRef: struct VerificationMethodRef<controllerAddress: struct ContractAddress<bytes: Bytes<32>>, methodId: Bytes<32>>, publicKey: Opaque<"JubjubPoint">>',
|
|
1430
1430
|
authority_0)
|
|
1431
1431
|
}
|
|
@@ -1440,14 +1440,14 @@ export const pureCircuits = {
|
|
|
1440
1440
|
if (!(typeof(descriptor_0) === 'object' && typeof(descriptor_0.version) === 'bigint' && descriptor_0.version >= 0n && descriptor_0.version <= 65535n && descriptor_0.authorizationId.buffer instanceof ArrayBuffer && descriptor_0.authorizationId.BYTES_PER_ELEMENT === 1 && descriptor_0.authorizationId.length === 32 && typeof(descriptor_0.decisionSequence) === 'bigint' && descriptor_0.decisionSequence >= 0n && descriptor_0.decisionSequence <= 18446744073709551615n && typeof(descriptor_0.state) === 'number' && descriptor_0.state >= 0 && descriptor_0.state <= 2 && typeof(descriptor_0.role) === 'number' && descriptor_0.role >= 0 && descriptor_0.role <= 1 && typeof(descriptor_0.signerVerificationMethodRef) === 'object' && typeof(descriptor_0.signerVerificationMethodRef.controllerAddress) === 'object' && descriptor_0.signerVerificationMethodRef.controllerAddress.bytes.buffer instanceof ArrayBuffer && descriptor_0.signerVerificationMethodRef.controllerAddress.bytes.BYTES_PER_ELEMENT === 1 && descriptor_0.signerVerificationMethodRef.controllerAddress.bytes.length === 32 && descriptor_0.signerVerificationMethodRef.methodId.buffer instanceof ArrayBuffer && descriptor_0.signerVerificationMethodRef.methodId.BYTES_PER_ELEMENT === 1 && descriptor_0.signerVerificationMethodRef.methodId.length === 32 && true && typeof(descriptor_0.didStateVersion) === 'bigint' && descriptor_0.didStateVersion >= 0n && descriptor_0.didStateVersion <= 18446744073709551615n && typeof(descriptor_0.verificationRelationship) === 'number' && descriptor_0.verificationRelationship >= 0 && descriptor_0.verificationRelationship <= 2 && descriptor_0.scopeCommitment.buffer instanceof ArrayBuffer && descriptor_0.scopeCommitment.BYTES_PER_ELEMENT === 1 && descriptor_0.scopeCommitment.length === 32 && descriptor_0.policyCommitment.buffer instanceof ArrayBuffer && descriptor_0.policyCommitment.BYTES_PER_ELEMENT === 1 && descriptor_0.policyCommitment.length === 32)) {
|
|
1441
1441
|
__compactRuntime.typeError('signerAuthorizationDecisionRoot',
|
|
1442
1442
|
'argument 1',
|
|
1443
|
-
'signer-authorization.compact line
|
|
1443
|
+
'signer-authorization.compact line 182 char 1',
|
|
1444
1444
|
'struct AuthorizedSignerDescriptor<version: Uint<0..65536>, authorizationId: Bytes<32>, decisionSequence: Uint<0..18446744073709551616>, state: Enum<AuthorizationState, active, suspended, revoked>, role: Enum<SignerRole, issuer, verifier>, signerVerificationMethodRef: struct VerificationMethodRef<controllerAddress: struct ContractAddress<bytes: Bytes<32>>, methodId: Bytes<32>>, signerPublicKey: Opaque<"JubjubPoint">, didStateVersion: Uint<0..18446744073709551616>, verificationRelationship: Enum<VerificationRelationship, assertionMethod, authentication, capabilityInvocation>, scopeCommitment: Bytes<32>, policyCommitment: Bytes<32>>',
|
|
1445
1445
|
descriptor_0)
|
|
1446
1446
|
}
|
|
1447
1447
|
if (!(domainCommitment_0.buffer instanceof ArrayBuffer && domainCommitment_0.BYTES_PER_ELEMENT === 1 && domainCommitment_0.length === 32)) {
|
|
1448
1448
|
__compactRuntime.typeError('signerAuthorizationDecisionRoot',
|
|
1449
1449
|
'argument 2',
|
|
1450
|
-
'signer-authorization.compact line
|
|
1450
|
+
'signer-authorization.compact line 182 char 1',
|
|
1451
1451
|
'Bytes<32>',
|
|
1452
1452
|
domainCommitment_0)
|
|
1453
1453
|
}
|
|
@@ -1464,21 +1464,21 @@ export const pureCircuits = {
|
|
|
1464
1464
|
if (!(typeof(descriptor_0) === 'object' && typeof(descriptor_0.version) === 'bigint' && descriptor_0.version >= 0n && descriptor_0.version <= 65535n && descriptor_0.authorizationId.buffer instanceof ArrayBuffer && descriptor_0.authorizationId.BYTES_PER_ELEMENT === 1 && descriptor_0.authorizationId.length === 32 && typeof(descriptor_0.decisionSequence) === 'bigint' && descriptor_0.decisionSequence >= 0n && descriptor_0.decisionSequence <= 18446744073709551615n && typeof(descriptor_0.state) === 'number' && descriptor_0.state >= 0 && descriptor_0.state <= 2 && typeof(descriptor_0.role) === 'number' && descriptor_0.role >= 0 && descriptor_0.role <= 1 && typeof(descriptor_0.signerVerificationMethodRef) === 'object' && typeof(descriptor_0.signerVerificationMethodRef.controllerAddress) === 'object' && descriptor_0.signerVerificationMethodRef.controllerAddress.bytes.buffer instanceof ArrayBuffer && descriptor_0.signerVerificationMethodRef.controllerAddress.bytes.BYTES_PER_ELEMENT === 1 && descriptor_0.signerVerificationMethodRef.controllerAddress.bytes.length === 32 && descriptor_0.signerVerificationMethodRef.methodId.buffer instanceof ArrayBuffer && descriptor_0.signerVerificationMethodRef.methodId.BYTES_PER_ELEMENT === 1 && descriptor_0.signerVerificationMethodRef.methodId.length === 32 && true && typeof(descriptor_0.didStateVersion) === 'bigint' && descriptor_0.didStateVersion >= 0n && descriptor_0.didStateVersion <= 18446744073709551615n && typeof(descriptor_0.verificationRelationship) === 'number' && descriptor_0.verificationRelationship >= 0 && descriptor_0.verificationRelationship <= 2 && descriptor_0.scopeCommitment.buffer instanceof ArrayBuffer && descriptor_0.scopeCommitment.BYTES_PER_ELEMENT === 1 && descriptor_0.scopeCommitment.length === 32 && descriptor_0.policyCommitment.buffer instanceof ArrayBuffer && descriptor_0.policyCommitment.BYTES_PER_ELEMENT === 1 && descriptor_0.policyCommitment.length === 32)) {
|
|
1465
1465
|
__compactRuntime.typeError('assertValidSignerAuthorizationProof',
|
|
1466
1466
|
'argument 1',
|
|
1467
|
-
'signer-authorization.compact line
|
|
1467
|
+
'signer-authorization.compact line 197 char 1',
|
|
1468
1468
|
'struct AuthorizedSignerDescriptor<version: Uint<0..65536>, authorizationId: Bytes<32>, decisionSequence: Uint<0..18446744073709551616>, state: Enum<AuthorizationState, active, suspended, revoked>, role: Enum<SignerRole, issuer, verifier>, signerVerificationMethodRef: struct VerificationMethodRef<controllerAddress: struct ContractAddress<bytes: Bytes<32>>, methodId: Bytes<32>>, signerPublicKey: Opaque<"JubjubPoint">, didStateVersion: Uint<0..18446744073709551616>, verificationRelationship: Enum<VerificationRelationship, assertionMethod, authentication, capabilityInvocation>, scopeCommitment: Bytes<32>, policyCommitment: Bytes<32>>',
|
|
1469
1469
|
descriptor_0)
|
|
1470
1470
|
}
|
|
1471
1471
|
if (!(typeof(authorizationProof_0) === 'object' && typeof(authorizationProof_0.signerVerificationMethodRef) === 'object' && typeof(authorizationProof_0.signerVerificationMethodRef.controllerAddress) === 'object' && authorizationProof_0.signerVerificationMethodRef.controllerAddress.bytes.buffer instanceof ArrayBuffer && authorizationProof_0.signerVerificationMethodRef.controllerAddress.bytes.BYTES_PER_ELEMENT === 1 && authorizationProof_0.signerVerificationMethodRef.controllerAddress.bytes.length === 32 && authorizationProof_0.signerVerificationMethodRef.methodId.buffer instanceof ArrayBuffer && authorizationProof_0.signerVerificationMethodRef.methodId.BYTES_PER_ELEMENT === 1 && authorizationProof_0.signerVerificationMethodRef.methodId.length === 32 && typeof(authorizationProof_0.createdAt) === 'bigint' && authorizationProof_0.createdAt >= 0n && authorizationProof_0.createdAt <= 18446744073709551615n && authorizationProof_0.challengeHash.buffer instanceof ArrayBuffer && authorizationProof_0.challengeHash.BYTES_PER_ELEMENT === 1 && authorizationProof_0.challengeHash.length === 32 && true && typeof(authorizationProof_0.signature) === 'object' && true && typeof(authorizationProof_0.signature.s) === 'bigint' && authorizationProof_0.signature.s >= 0 && authorizationProof_0.signature.s <= __compactRuntime.MAX_FIELD)) {
|
|
1472
1472
|
__compactRuntime.typeError('assertValidSignerAuthorizationProof',
|
|
1473
1473
|
'argument 2',
|
|
1474
|
-
'signer-authorization.compact line
|
|
1474
|
+
'signer-authorization.compact line 197 char 1',
|
|
1475
1475
|
'struct Proof<signerVerificationMethodRef: struct VerificationMethodRef<controllerAddress: struct ContractAddress<bytes: Bytes<32>>, methodId: Bytes<32>>, createdAt: Uint<0..18446744073709551616>, challengeHash: Bytes<32>, publicKey: Opaque<"JubjubPoint">, signature: struct Signature<r: Opaque<"JubjubPoint">, s: Field>>',
|
|
1476
1476
|
authorizationProof_0)
|
|
1477
1477
|
}
|
|
1478
1478
|
if (!(typeof(authority_0) === 'object' && authority_0.domainCommitment.buffer instanceof ArrayBuffer && authority_0.domainCommitment.BYTES_PER_ELEMENT === 1 && authority_0.domainCommitment.length === 32 && typeof(authority_0.verificationMethodRef) === 'object' && typeof(authority_0.verificationMethodRef.controllerAddress) === 'object' && authority_0.verificationMethodRef.controllerAddress.bytes.buffer instanceof ArrayBuffer && authority_0.verificationMethodRef.controllerAddress.bytes.BYTES_PER_ELEMENT === 1 && authority_0.verificationMethodRef.controllerAddress.bytes.length === 32 && authority_0.verificationMethodRef.methodId.buffer instanceof ArrayBuffer && authority_0.verificationMethodRef.methodId.BYTES_PER_ELEMENT === 1 && authority_0.verificationMethodRef.methodId.length === 32 && true)) {
|
|
1479
1479
|
__compactRuntime.typeError('assertValidSignerAuthorizationProof',
|
|
1480
1480
|
'argument 3',
|
|
1481
|
-
'signer-authorization.compact line
|
|
1481
|
+
'signer-authorization.compact line 197 char 1',
|
|
1482
1482
|
'struct SignerAuthorizationAuthority<domainCommitment: Bytes<32>, verificationMethodRef: struct VerificationMethodRef<controllerAddress: struct ContractAddress<bytes: Bytes<32>>, methodId: Bytes<32>>, publicKey: Opaque<"JubjubPoint">>',
|
|
1483
1483
|
authority_0)
|
|
1484
1484
|
}
|
|
@@ -1495,14 +1495,14 @@ export const pureCircuits = {
|
|
|
1495
1495
|
if (!(typeof(previous_0) === 'object' && typeof(previous_0.version) === 'bigint' && previous_0.version >= 0n && previous_0.version <= 65535n && previous_0.authorizationId.buffer instanceof ArrayBuffer && previous_0.authorizationId.BYTES_PER_ELEMENT === 1 && previous_0.authorizationId.length === 32 && typeof(previous_0.decisionSequence) === 'bigint' && previous_0.decisionSequence >= 0n && previous_0.decisionSequence <= 18446744073709551615n && typeof(previous_0.state) === 'number' && previous_0.state >= 0 && previous_0.state <= 2 && typeof(previous_0.role) === 'number' && previous_0.role >= 0 && previous_0.role <= 1 && typeof(previous_0.signerVerificationMethodRef) === 'object' && typeof(previous_0.signerVerificationMethodRef.controllerAddress) === 'object' && previous_0.signerVerificationMethodRef.controllerAddress.bytes.buffer instanceof ArrayBuffer && previous_0.signerVerificationMethodRef.controllerAddress.bytes.BYTES_PER_ELEMENT === 1 && previous_0.signerVerificationMethodRef.controllerAddress.bytes.length === 32 && previous_0.signerVerificationMethodRef.methodId.buffer instanceof ArrayBuffer && previous_0.signerVerificationMethodRef.methodId.BYTES_PER_ELEMENT === 1 && previous_0.signerVerificationMethodRef.methodId.length === 32 && true && typeof(previous_0.didStateVersion) === 'bigint' && previous_0.didStateVersion >= 0n && previous_0.didStateVersion <= 18446744073709551615n && typeof(previous_0.verificationRelationship) === 'number' && previous_0.verificationRelationship >= 0 && previous_0.verificationRelationship <= 2 && previous_0.scopeCommitment.buffer instanceof ArrayBuffer && previous_0.scopeCommitment.BYTES_PER_ELEMENT === 1 && previous_0.scopeCommitment.length === 32 && previous_0.policyCommitment.buffer instanceof ArrayBuffer && previous_0.policyCommitment.BYTES_PER_ELEMENT === 1 && previous_0.policyCommitment.length === 32)) {
|
|
1496
1496
|
__compactRuntime.typeError('assertValidSignerAuthorizationUpdate',
|
|
1497
1497
|
'argument 1',
|
|
1498
|
-
'signer-authorization.compact line
|
|
1498
|
+
'signer-authorization.compact line 228 char 1',
|
|
1499
1499
|
'struct AuthorizedSignerDescriptor<version: Uint<0..65536>, authorizationId: Bytes<32>, decisionSequence: Uint<0..18446744073709551616>, state: Enum<AuthorizationState, active, suspended, revoked>, role: Enum<SignerRole, issuer, verifier>, signerVerificationMethodRef: struct VerificationMethodRef<controllerAddress: struct ContractAddress<bytes: Bytes<32>>, methodId: Bytes<32>>, signerPublicKey: Opaque<"JubjubPoint">, didStateVersion: Uint<0..18446744073709551616>, verificationRelationship: Enum<VerificationRelationship, assertionMethod, authentication, capabilityInvocation>, scopeCommitment: Bytes<32>, policyCommitment: Bytes<32>>',
|
|
1500
1500
|
previous_0)
|
|
1501
1501
|
}
|
|
1502
1502
|
if (!(typeof(next_0) === 'object' && typeof(next_0.version) === 'bigint' && next_0.version >= 0n && next_0.version <= 65535n && next_0.authorizationId.buffer instanceof ArrayBuffer && next_0.authorizationId.BYTES_PER_ELEMENT === 1 && next_0.authorizationId.length === 32 && typeof(next_0.decisionSequence) === 'bigint' && next_0.decisionSequence >= 0n && next_0.decisionSequence <= 18446744073709551615n && typeof(next_0.state) === 'number' && next_0.state >= 0 && next_0.state <= 2 && typeof(next_0.role) === 'number' && next_0.role >= 0 && next_0.role <= 1 && typeof(next_0.signerVerificationMethodRef) === 'object' && typeof(next_0.signerVerificationMethodRef.controllerAddress) === 'object' && next_0.signerVerificationMethodRef.controllerAddress.bytes.buffer instanceof ArrayBuffer && next_0.signerVerificationMethodRef.controllerAddress.bytes.BYTES_PER_ELEMENT === 1 && next_0.signerVerificationMethodRef.controllerAddress.bytes.length === 32 && next_0.signerVerificationMethodRef.methodId.buffer instanceof ArrayBuffer && next_0.signerVerificationMethodRef.methodId.BYTES_PER_ELEMENT === 1 && next_0.signerVerificationMethodRef.methodId.length === 32 && true && typeof(next_0.didStateVersion) === 'bigint' && next_0.didStateVersion >= 0n && next_0.didStateVersion <= 18446744073709551615n && typeof(next_0.verificationRelationship) === 'number' && next_0.verificationRelationship >= 0 && next_0.verificationRelationship <= 2 && next_0.scopeCommitment.buffer instanceof ArrayBuffer && next_0.scopeCommitment.BYTES_PER_ELEMENT === 1 && next_0.scopeCommitment.length === 32 && next_0.policyCommitment.buffer instanceof ArrayBuffer && next_0.policyCommitment.BYTES_PER_ELEMENT === 1 && next_0.policyCommitment.length === 32)) {
|
|
1503
1503
|
__compactRuntime.typeError('assertValidSignerAuthorizationUpdate',
|
|
1504
1504
|
'argument 2',
|
|
1505
|
-
'signer-authorization.compact line
|
|
1505
|
+
'signer-authorization.compact line 228 char 1',
|
|
1506
1506
|
'struct AuthorizedSignerDescriptor<version: Uint<0..65536>, authorizationId: Bytes<32>, decisionSequence: Uint<0..18446744073709551616>, state: Enum<AuthorizationState, active, suspended, revoked>, role: Enum<SignerRole, issuer, verifier>, signerVerificationMethodRef: struct VerificationMethodRef<controllerAddress: struct ContractAddress<bytes: Bytes<32>>, methodId: Bytes<32>>, signerPublicKey: Opaque<"JubjubPoint">, didStateVersion: Uint<0..18446744073709551616>, verificationRelationship: Enum<VerificationRelationship, assertionMethod, authentication, capabilityInvocation>, scopeCommitment: Bytes<32>, policyCommitment: Bytes<32>>',
|
|
1507
1507
|
next_0)
|
|
1508
1508
|
}
|
|
@@ -4,5 +4,5 @@
|
|
|
4
4
|
"sourceRoot": "../../../../",
|
|
5
5
|
"sources": ["src/credentials.compact", "src/./credentials/./types.compact", "src/./credentials/./proofs.compact", "src/./credentials/./signer-authorization.compact", "src/./credentials/./holder-bindings.compact", "src/./credentials/./status-bindings.compact", "compiler/standard-library.compact"],
|
|
6
6
|
"names": [],
|
|
7
|
-
"mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcA;;;;;;;;;;MCPA,AAAA,oBAIC;;OAAA;MAED,AAAA,wBAaC;;OAAA;MAOD,AAAA,gCAWC;;OAAA;MCXD,AAAA,eAcC;;OAAA;MAQD,AAAA,kBAEC;;OAAA;MAED,AAAA,sBAEC;;OAAA;MAED,AAAA,6BAEC;;OAAA;MAED,AAAA,yBAEC;;OAAA;MA+CD,AAAA,wBAKC;;OAAA;MAED,AAAA,4BAKC;;OAAA;MAED,AAAA,sBAKC;;OAAA;MAED,AAAA,0BAKC;;OAAA;MAED,AAAA,iCASC;;OAAA;MAED,AAAA,6BASC;;OAAA;MAQD,AAAA,+BAKC;;OAAA;MAED,AAAA,mCAKC;;OAAA;MAED,AAAA,0CASC;;OAAA;MAED,AAAA,sCASC;;OAAA;MCrKD,AAAA,qCA0CC;;OAAA;MAED,AAAA,8BAKC;;OAAA;MAQD,AAAA,qBAGC;;OAAA;MAED,AAAA,
|
|
7
|
+
"mappings": "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"
|
|
8
8
|
}
|