diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml new file mode 100644 index 00000000..e9ed8fc8 --- /dev/null +++ b/.github/workflows/docs.yml @@ -0,0 +1,23 @@ +name: Build and deploy API docs + +on: + push: + branches: + - main + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v1 + - uses: actions/setup-node@v1 + + - name: Build docs + run: yarn typedoc + + - name: Deploy docs + uses: peaceiris/actions-gh-pages@v4 + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_dir: ./__typedoc__ \ No newline at end of file diff --git a/.gitignore b/.gitignore index 8732bc19..d0bce85d 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,4 @@ node_modules .lvimrc /dist /lib +/__typedoc__ diff --git a/README.md b/README.md index d75aea26..762f582d 100644 --- a/README.md +++ b/README.md @@ -36,7 +36,7 @@ the [WASM wrapper](https://github.com/docknetwork/crypto-wasm). - [Social KYC](#social-kyc) - [Verifiable encryption using SAVER](#verifiable-encryption-using-saver) - [Encoding for verifiable encryption](#encoding-for-verifiable-encryption) - - [Bound check using LegoGroth16](#bound-check-using-legogroth16) + - [Bound check (range proof)](#bound-check-range-proof) - [Encoding for negative or decimal numbers](#encoding-for-negative-or-decimal-numbers) - [Optimization](#optimization) - [Working with messages as JS objects](#working-with-messages-as-js-objects) @@ -1312,3 +1312,5 @@ The Circom programs and corresponding R1CS and WASM files for the tests are [her ### Anonymous credentials The composite proof system is used to implement anonymous credentials. See [here](src/anonymous-credentials/) for details. + +[Slides](https://www.slideshare.net/SSIMeetup/anonymous-credentials-with-range-proofs-verifiable-encryption-zksnarks-circom-support-and-blinded-issuance-lovesh-harchandani) and [video](https://www.youtube.com/watch?v=e_E_6Fx5dro) for a presentation given at SSI meetup. Mostl of the presentation goes over the code, mostly anonymous credentials from this library. \ No newline at end of file diff --git a/package.json b/package.json index 58244730..a95c73f5 100644 --- a/package.json +++ b/package.json @@ -20,7 +20,8 @@ "test-bbs+": "TEST_SIGNATURE_SCHEME=BBS+ yarn jest", "test-ps": "TEST_SIGNATURE_SCHEME=PS yarn jest", "test-bbdt16": "TEST_SIGNATURE_SCHEME=BBDT16 yarn jest", - "test-all": "TEST_SIGNATURE_SCHEME=BBS yarn jest; TEST_SIGNATURE_SCHEME=BBS+ yarn jest; TEST_SIGNATURE_SCHEME=PS yarn jest; TEST_SIGNATURE_SCHEME=BBDT16 yarn jest" + "test-all": "TEST_SIGNATURE_SCHEME=BBS yarn jest; TEST_SIGNATURE_SCHEME=BBS+ yarn jest; TEST_SIGNATURE_SCHEME=PS yarn jest; TEST_SIGNATURE_SCHEME=BBDT16 yarn jest", + "typedoc": "typedoc src --plugin typedoc-github-theme --out __typedoc__" }, "license": "Apache-2.0", "private": false, @@ -40,7 +41,8 @@ "json-stringify-deterministic": "^1.0.11", "lodash": "^4.17.21", "lzutf8": "0.6.3", - "semver": "^7.6.0" + "semver": "^7.6.0", + "typedoc-github-theme": "^0.1.2" }, "devDependencies": { "@types/jest": "^29.1.0", @@ -61,6 +63,7 @@ "r1csfile": "^0.0.41", "ts-jest": "^29.1.0", "ts-node": "^10.9.1", + "typedoc": "^0.26.11", "typescript": "5.3.3" } } diff --git a/src/accumulator/kb-universal-accumulator.ts b/src/accumulator/kb-universal-accumulator.ts index f4c73ea0..94c9ac42 100644 --- a/src/accumulator/kb-universal-accumulator.ts +++ b/src/accumulator/kb-universal-accumulator.ts @@ -30,9 +30,9 @@ import { /** * KB universal accumulator. Its composed of 2 accumulators, one for accumulating elements that are "members" and one - * for "non-members". But this detail is largely abstracted away from. All possible "members" and "non-members" of this - * accumulator are called its domain and during initialization, the domain needs to be decided passed. The domain can be - * extended at any point. + * for "non-members". But this detail is largely abstracted away. All possible "members" and "non-members" of this + * accumulator are called its domain and during initialization, the domain needs to be known/passed. The domain can be + * extended at any point and any number of times. */ export class KBUniversalAccumulator extends Accumulator { // @ts-ignore diff --git a/src/anonymous-credentials/README.md b/src/anonymous-credentials/README.md index 374f017e..dba75b6a 100644 --- a/src/anonymous-credentials/README.md +++ b/src/anonymous-credentials/README.md @@ -2,19 +2,138 @@ This directory contains an [anonymous credentials](https://blog.dock.io/anonymous-credentials/) implementation using the [composite proof system](./../composite-proof/index.ts). +All the objects described below have semantic versioning and can be accessing using `this.version`. + ## Schema -Specifies all the fields of the credential and their structure (nesting). Because anonymous credentials allow to hide any +Specifies all the attributes of the credential and their structure (nesting). Because anonymous credentials allow to hide any number of attributes of the credential, it must be possible to know what attributes were part of the issued credential. Schema also defines the **encoding** of each attribute. Encoding determines how the credential attribute value must be converted to a positive integer (prime field, a [finite field](https://en.wikipedia.org/wiki/Finite_field) of prime order, to be precise) -before passing to the crypto (signing, proving) algorithms. Choosing an appropriate encoding process is essential when doing +before passing to the crypto (signing, proving) algorithms. Choosing an appropriate encoding process is essential when doing predicates like enforcing bounds on attributes (range proofs), verifiable encryption of attributes or when using it in [predicates](https://blog.dock.io/circom-language-integration/) written in [Circom](https://docs.circom.io/). For more details on the need of encoding see [here](./../../README.md#encoding-for-negative-or-decimal-numbers) and [here](./../../README.md#encoding-for-verifiable-encryption). It expects the schema in the [JSON-schema syntax](https://json-schema.org/), draft-07. The schema can define the attributes as literals (string, numbers, datetime) or as objects or arrays. +A `CredentialSchema` object can either have embedded schema or non-embedded scheme. In the former case, the attributes and their encodings +are expected to be present in the `properties` key of the schema whereas in the latter, these are supposed to be fetched from a url specified +in the `$id` key. The latter is useful when a uniform scheme needs to be enforced in all credentials. + +Example of creating an embedded schema. For each attribute, its encoding is determined by the `type` and other parameters. +Schema `properties` must have the key `credentialSubject` + +```ts +// Get essential properties +const jsonSchema = CredentialSchema.essential(); +// Set custom properties under the top level key `credentialSubject` +jsonSchema.properties.credentialSubject = { + type: 'object', + properties: { + fname: { type: 'string' }, + score: { type: 'integer', minimum: -100 }, // attribute `score` can have a minimum value of -100 and is always an integer + long: { type: 'number', minimum: 0, multipleOf: 0.01 }, // attribute `long` can have a minimum value of 0.00 and has 2 decimal places so it can have values like 0.45, 4.25, 90.68, etc + l1: { type: 'decimalNumber', minimum: -180, decimalPlaces: 3 }, // attribute `l1` can have a minimum value of -180.000 and has 3 decimal places so it can have values like -100.456, 104.251, 90.680, etc + l2: { type: 'positiveDecimalNumber', decimalPlaces: 1 }, // attribute `l2` can have a minimum value of 0.0 and has 1 decimal places so it can have values like 100.4, 5.2, 9.6, etc + dateOfRegistration: { type: 'string', format: 'date' }, // attribute `dateOfRegistration` needs to specify a valid date like 1999-01-01 + timeOfBirth: { type: 'string', format: 'date-time' }, // attribute `timeOfBirth` needs to specify a valid date-time like 2023-09-14T19:26:40.488Z + SSN: { $ref: '#/definitions/encryptableString' }, // attribute `SSN` can be (verifiably) encrypted so instructs the `CredentialSchema` to encode in a appropriate manner. See main Readme for such encoding + } +}; +const schema = new CredentialSchema(jsonSchema); +console.assert(schema.hasEmbeddedJsonSchema()); +``` + +Example of creating a non-embedded schema. The schema will be fetched from the url `https://example.com?hash=abc123ff` using +the callback `schemaGetter` (defined by the caller) which expects the url as its only parameter. The url in the `$id` +field doesn't have to be an HTTP(S) url but could be any identifier which the callback `schemaGetter` is capable of using. + +```ts +const nonEmbeddedSchema = { + $id: 'https://example.com?hash=abc123ff', + [META_SCHEMA_STR]: 'http://json-schema.org/draft-07/schema#', + type: 'object', +}; +const schema = await CredentialSchema.newSchemaFromExternal(nonEmbeddedSchema, schemaGetter); +console.assert(schema.hasEmbeddedJsonSchema()); +``` + +Schema can be converted to and from JSON + +```ts +// Convert to JSON +const j = schema.toJSON(); +// Recreate from JSON +const s = CredentialSchema.fromJSON(j); +``` + +A schema could be generated by looking at the credential attributes. Say a JSON object `cred` is created with the necessary attributes, then +the following will create the corresponding schema object. + +```ts +// Set whatever properties are known for sure +const jsonSchema = CredentialSchema.essential(); +// Rest of the properties are generated using `cred` +const schema = CredentialSchema.generateAppropriateSchema( + cred, + new CredentialSchema(jsonSchema) +); +``` + +While creating schema, parsing options can be passed when can allow scheme generation to use defaults and/or set the defaults for numeric values + +```ts +const schema = new CredentialSchema(jsonSchema, { useDefaults: true, defaultDecimalPlaces: 5 }); +``` + +Schema keys can also be nested objects or arrays. The following has an array of nested objects and some top level keys in addition to `credentialSubject` + +```ts +const jsonSchema = CredentialSchema.essential(); +const item = { + type: 'object', + properties: { + name: { type: 'string' }, + location: { + type: 'object', + properties: { + name: { type: 'string' }, + geo: { + type: 'object', + properties: { + lat: { type: 'number', minimum: -90, multipleOf: 0.001 }, + long: { type: 'number', minimum: -180, multipleOf: 0.001 } + } + } + } + } + } +}; + +// Set the credentialSubject to an array of nested objects of size 3. The array size must be known +jsonSchema.properties[credentialSubject] = { + type: 'array', + items: [item, item, item] +}; + +// Set a top level key `issuer` +jsonSchema.properties['issuer'] = { + type: 'object', + properties: { + name: { type: 'string' }, + desc: { type: 'string' }, + logo: { type: 'string' } + } +}; + +// Set more top level keys +jsonSchema.properties['issuanceDate'] = { type: 'string', format: 'date' }; +jsonSchema.properties['expirationDate'] = { type: 'string', format: 'date' }; + +const schema = new CredentialSchema(jsonSchema); +``` + Schema [code](./schema.ts) and [tests](../../tests/anonymous-credentials/schema.spec.ts). ## Credentials @@ -26,9 +145,198 @@ the verifier. Some other attributes (which can be considered metadata) are alway A [CredentialBuilder](./credential-builder.ts) is used to build a credential by setting various attributes and then signed using the issuer's secret key resulting in a [Credential](./credential.ts) which can then be verified using the -public key of the issuer. A credential might have a `status` field indicating whether the credential can be revoked or not. Currently only 1 -mechanism is supported and that is accumulator but the `status` property is oblivious to that. However there are 2 kinds of -accumulators that we support. +public key of the issuer. A credential might have a `credentialStatus` field indicating whether the credential can be revoked or not. Currently only 1 +mechanism is supported and that is accumulator but the `credentialStatus` property is oblivious to that. However, there are several kinds of +accumulators that we support. A VB positive accumulator supports only membership proofs but a VB universal accumulator supports non-membership proofs +as well. A KB universal accumulator supports both membership and non-membership proofs but the non-membership proofs are relatively efficient than VB +accumulator. However, creating and updating the accumulator has double the cost which is acceptable since done by the signer/revocation authority. This is +because a KB universal accumulator is composed of 2 VB positive accumulators. + +The following creates a schema, and then a credential from the schema. The example uses `BBSCredentialBuilder`, a subclass of `CredentialBuilder`, for BBS signatures +but other schemes work similarly. Calling `BBSCredentialBuilder.sign` will return a `BBSCredential` object. + +```ts +// Signer's one time setup, creates params and keys. +// The number 1 doesn't matter for BBS, BBS+, BBDT16 as params can be extended +const params = BBSSignatureParams.generate(1, SignatureLabelBytes); +// Create secret and public keys +const keypair = BBSKeypair.generate(params); +const sk = keypair.sk; +const pk = keypair.pk; + +// Create schema for credential +const schema = CredentialSchema.essential(); +schema.properties[credentialSubject] = { + type: 'object', + properties: { + fname: { type: 'string' }, + lname: { type: 'string' }, + sensitive: { + type: 'object', + properties: { + email: { type: 'string' }, + phone: { type: 'string' }, + SSN: { $ref: '#/definitions/encryptableString' } + } + } + } +}; +const credSchema = new CredentialSchema(schema); + +// Set schema +const builder = new BBSCredentialBuilder(); +builder.schema = credSchema; + +// Set attributes and sign +builder.subject = { + fname: 'John', + lname: 'Smith', + sensitive: { + phone: '810-1234567', + email: 'john.smith@example.com', + SSN: '123-456789-0' + } +}; +const cred = builder.sign(sk); + +// Verify credential using public key +console.assert(cred.verify(pk).verified); +``` + +Credential can be converted to and from JSON + +```ts +const j = cred.toJSON(); +const c = BBSCredential.fromJSON(credJson); +``` + +Schema for credentials can be generated by inferring from the credential object by setting the parameter `requireSameFieldsAsSchema` to false. The example +below generates a bare minimum schema and does not specify any credential attributes but its possible to specify only some attribute types/encodings in +the schema and let the rest be autogenerated. + +```ts +const builder = new BBSCredentialBuilder(); +// Set the credential attributes +builder.subject = { + fname: 'John', + lname: 'Smith', + city: 'NY', + education: { university: 'Example', major: 'Nothing' }, + someNumber: 2.5, + someInteger: 5, +}; +// Generate a bare minimum schema +builder.schema = new CredentialSchema(CredentialSchema.essential(), { useDefaults: true }); +// Before signing, generate schema for the credential attributes +const cred = builder.sign(sk, undefined, { requireSameFieldsAsSchema: false }); +// Verify credential using public key +console.assert(cred.verify(pk).verified); +``` + +Its possible to specify top level fields, i.e. attributes at the same level as `credentialSubject` and not under it. Also attributes +can be arrays as shown below. + +```ts +const jsonSchema = CredentialSchema.essential(); +const item = { + type: 'object', + properties: { + name: { type: 'string' }, + location: { + type: 'object', + properties: { + name: { type: 'string' }, + geo: { + type: 'object', + properties: { + lat: { type: 'number', minimum: -90, multipleOf: 0.001 }, + long: { type: 'number', minimum: -180, multipleOf: 0.001 } + } + } + } + } + } +}; +jsonSchema.properties[credentialSubject] = { + type: 'array', + items: [item, item, item] +}; +jsonSchema.properties['issuer'] = { + type: 'object', + properties: { + name: { type: 'string' }, + desc: { type: 'string' }, + logo: { type: 'string' } + } +}; +jsonSchema.properties['issuanceDate'] = { type: 'string', format: 'date' }; +jsonSchema.properties['expirationDate'] = { type: 'string', format: 'date' }; + +const credSchema = new CredentialSchema(jsonSchema); + +const builder = new CredentialBuilder(); +builder.schema = credSchema; + +builder.subject = [ + { + name: 'Random', + location: { + name: 'Somewhere', + geo: { + lat: -23.658, + long: 2.556 + } + } + }, + { + name: 'Random-1', + location: { + name: 'Somewhere-1', + geo: { + lat: 35.01, + long: -40.987 + } + } + }, + { + name: 'Random-2', + location: { + name: 'Somewhere-2', + geo: { + lat: -67.0, + long: -10.12 + } + } + } +]; +builder.setTopLevelField('issuer', { + name: 'An issuer', + desc: 'Just an issuer', + logo: 'https://images.example-issuer.com/logo.png' +}); +builder.setTopLevelField('issuanceDate', 1662010849700); +builder.setTopLevelField('expirationDate', 1662011950934); + +const cred = builder.sign(sk); +``` + +For credentials that can be revoked (see main Readme for background on revocation), its `credentialStatus` field must be set accordingly +by calling `setCredentialStatus`. In the following example, `dock:accumulator:accumId123` is the unique id of the accumulator, +`MEM_CHECK_STR` means that revocation status should check membership in the accumulator, `user:A-123` is the unique id of the +credential that is put in the accumulator and `RevocationStatusProtocol.Vb22` means that VB22 accumulator is used. + +```ts +const builder = new BBSCredentialBuilder(); +builder.schema = credSchema; + +builder.subject = { + // .... attributes +}; + +builder.setCredentialStatus('dock:accumulator:accumId123', MEM_CHECK_STR, 'user:A-123', RevocationStatusProtocol.Vb22); + +const cred = builder.sign(sk); +``` See these [tests](../../tests/anonymous-credentials/credential.spec.ts) for examples of credential issuance, verification and (de)serialization. @@ -45,10 +353,600 @@ The `PresentationBuilder` allows adding a `context` for specifying things like p or anything else and a `nonce` for replay protection. As part a `Presentation`, included is a [PresentationSpecification](./presentation-specification.ts) which specifies what the presentation is proving like what credentials, what's being revealed, which attributes are being proven equal, -bounds being enforced, attributes being encrypted and their ciphertext, accumulator used, etc. Note that any binary values needed in the -`Presentation` JSON are encoded as base58. +bounds being enforced, attributes being encrypted and their ciphertext, accumulator used, etc. `PresentationSpecification` describes +what is being cryptographically proved, not what the verifier is expecting the holder to prove. Thus, the verifier must check if the presentation +is indeed proving what it needs to be proven. Eg, verifier needs the holder to satisfy the bounds [30, 45) on a attribute but the holder +decides to satisfy [10, 15). Now the `PresentationSpecification` will specify the bounds as 10 and 15 and the verifier should detect that they +are not what it asked for and reject the presentation. +Note that any binary values needed in the `Presentation` JSON are encoded as base58. + +The following example creates a presentation from 2 credentials, reveals attributes and proves certain attributes among them equal. +The holder has 2 credentials, `credential1` and `credential2` as shown. Both are `BBSCredential`s but a presentation can accept +credentials of any type, eg. a presentation can have 4 credentials, 2 `BBSCredential`s, 1 `BBSPlusCredential`s and 1 `PSCredential`. +Also, these can be from different signers (have different public keys). +A presentation assigns a unique 0-based index to each credential with a credential added. This index is then used to refer to +that credential when revealing attributes (with `markAttributesRevealed`) or enforcing predicates (with `enforceAttributeEquality`, `enforceAttributeInequality`, etc) +Predicates satisfied in the presentation often contain a field `protocol` which refers to the crypto protocol used to prove the predicate. +Eg. for proving inequality, the following shows `Uprove` which is the identifier of the protocol. This is to allow +multiple protocols for proving the predicate and each application can choose the protocol which is appropriate for its needs. + +Examples from now on will use a helper `areBothEqual` to compare "any" kind of objects/arrays for equality. + +```ts +const jsonSchema1 = CredentialSchema.essential(); +jsonSchema1.jsonSchema[SUBJECT_STR] = { + type: 'object', + properties: { + fname: { type: 'string' }, + lname: { type: 'string' }, + email: { type: 'string' }, + SSN: { $ref: '#/definitions/encryptableString' }, + userId: { $ref: '#/definitions/encryptableCompString' }, + country: { type: 'string' }, + city: { type: 'string' }, + timeOfBirth: { type: 'integer', minimum: 0 }, + score: { type: 'number', minimum: -100, multipleOf: 0.1 }, + secret: { type: 'string' } + } +}; + +// Signer 1 with keys `sk1`, `pk1`, creates `credential1` +const builder1 = new BBSCredentialBuilder(); +builder1.schema = new CredentialSchema(jsonSchema1); +builder1.subject = { + fname: 'John', + lname: 'Smith', + email: 'john.smith@example.com', + SSN: '123-456789-0', + userId: 'user:123-xyz-#', + country: 'USA', + city: 'New York', + timeOfBirth: 1662010849619, + score: -13.5, + secret: 'my-secret-that-wont-tell-anyone' +}; +const credential1 = builder1.sign(sk1); + +const jsonSchema2 = CredentialSchema.essential(); +jsonSchema2.properties[SUBJECT_STR] = { + type: 'object', + properties: { + fname: { type: 'string' }, + lname: { type: 'string' }, + isbool: { type: 'boolean' }, + sensitive: { + type: 'object', + properties: { + secret: { type: 'string' }, + email: { type: 'string' }, + SSN: { $ref: '#/definitions/encryptableString' }, + userId: { $ref: '#/definitions/encryptableCompString' } + } + }, + location: { + type: 'object', + properties: { + country: { type: 'string' }, + city: { type: 'string' } + } + }, + timeOfBirth: { type: 'integer', minimum: 0 }, + physical: { + type: 'object', + properties: { + height: { type: 'number', minimum: 0, multipleOf: 0.1 }, + weight: { type: 'number', minimum: 0, multipleOf: 0.1 }, + BMI: { type: 'number', minimum: 0, multipleOf: 0.01 } + } + }, + score: { type: 'number', multipleOf: 0.1, minimum: -100 } + } +}; + +// Signer 2 with keys `sk2`, `pk2`, creates `credential2` +const builder2 = new BBSCredentialBuilder(); +builder2.schema = new CredentialSchema(jsonSchema2);; +builder2.subject = { + fname: 'John', + lname: 'Smith', + isbool: true, + sensitive: { + secret: 'my-secret-that-wont-tell-anyone', + email: 'john.smith@example.com', + SSN: '123-456789-0', + userId: 'user:123-xyz-#' + }, + location: { + country: 'USA', + city: 'New York' + }, + timeOfBirth: 1662010849619, + physical: { + height: 181.5, + weight: 210, + BMI: 23.25 + }, + score: -13.5 +}; +const credential2 = builder2.sign(sk2); + +// Holder starts creating presentation +const presBuilder = new PresentationBuilder(); +// PresentationBuilder assigns index 0 to credential1 +console.assert(presBuilder.addCredential(credential1) === 0); +// PresentationBuilder assigns index 1 to credential2 +console.assert(presBuilder.addCredential(credential2) === 1); + +// Reveal 2 attributes of credential1. Note that the attribute name needs to be provided in a flattened manner, i.e. .... +presBuilder.markAttributesRevealed( + 0, // credential1 has index 0 as it was added first + new Set(['credentialSubject.fname', 'credentialSubject.lname']) +); +// Reveal 3 attributes of credential2. +presBuilder.markAttributesRevealed( + 1, // credential2 has index 1 as it was added second + new Set([ + 'credentialSubject.fname', + 'credentialSubject.location.country', + 'credentialSubject.physical.BMI' + ]) +); + +// Enforce equality of attribute credentialSubject.SSN of credential1 and credentialSubject.sensitive.SSN of credential2 +presBuilder.enforceAttributeEquality( + [0, 'credentialSubject.SSN'], // credential1 has index 0 + [1, 'credentialSubject.sensitive.SSN'] // credential2 has index 1 +); + +// Enforce equality of attribute credentialSubject.city of credential1 and credentialSubject.location.city of credential2 +presBuilder.enforceAttributeEquality( + [0, 'credentialSubject.city'], // credential1 has index 0 + [1, 'credentialSubject.location.city'] // credential2 has index 1 +); + +// Enforce that attribute credentialSubject.email of credential1 is not equal to alice@example.com +presBuilder.enforceAttributeInequality( + 0, // credential1 has index 0 + 'credentialSubject.email', + 'alice@example.com' +); +// Enforce that attribute credentialSubject.email of credential1 is not equal to bob@example.com +presBuilder.enforceAttributeInequality( + 0, // credential1 has index 0 + 'credentialSubject.email', + 'bob@example.com' +); + +// Can contain metadata about the presentation like terms of use or any holder specified data called self-attested attributes. Could be a JSON string as well +presBuilder.context = 'some context'; +// A nonce given by the verifier +presBuilder.nonce = new Uint8Array([0, 1, 100, 250, ...]); + +// Generate the presentation +const pres = presBuilder.finalize(); + +// In addition to checking the cryptographic validity of the presentation `pres`, the verifier checks if the revealed attributes +// and predicates match his expectation + +// Verifier checks the context and nonce. The exact checking of context will depend on the application +console.assert(pres.context === 'some context'); +console.assert(areBothEqual(pres.nonce, new Uint8Array([0, 1, 100, 250, ...]))); + +// Presentation contains 2 credentials +console.assert(pres.spec.credentials.length === 2); + +// Presentation's first credential reveals the expected attributes. +console.assert( + areBothEqual( + pres.spec.credentials[0].revealedAttributes, // 0 refers to first credential, which is credential1 + { + credentialSubject: { + fname: 'John', + lname: 'Smith' + } + } + ) +); + +// Presentation's second credential reveals the expected attributes. +console.assert( + areBothEqual( + pres.spec.credentials[1].revealedAttributes, // 1 refers to second credential, which is credential2 + { + credentialSubject: { + fname: 'John', + location: { country: 'USA' }, + physical: { BMI: 23.25 } + } + } + ) +); + +// Verifier checks that the desired attribute are proved equal +console.assert( + areBothEqual( + pres4.spec.attributeEqualities, + [ + [[0, 'credentialSubject.SSN'], [1, 'credentialSubject.sensitive.SSN']], // 0 refers to credential1, 1 refers to credential2 + [[0, 'credentialSubject.city'], [1, 'credentialSubject.location.city']], // 0 refers to credential1, 1 refers to credential2 + ] + ) +); + +// Verifier checks that the desired attribute inequalities are enforced for credential1. +console.assert( + areBothEqual( + pres.spec.credentials[0].attributeInequalities, // 0 refers to credential1 + { + credentialSubject: { + email: [ + { inEqualTo: 'alice@example.com', protocol: 'Uprove' }, + { inEqualTo: 'bob@example.com', protocol: 'Uprove' } + ] + } + } + ) +); + +// Verify the cryptographic validity of the presentation +// Create a map of credential index -> public key to verify the presentation +const pks = new Map(); +// Public key corresponding to credential1 is pk1 and credential1's index is 0 +pks.set(0, pk1); +// Public key corresponding to credential2 is pk2 and credential2's index is 1 +pks.set(1, pk2); +console.assert(pres.verify(pks).verified); +``` + +The holder can prove that certain attributes of the credential satisfy certain bounds, i.e. minimum and maximum. These are also called +range proofs. There are several supported protocols for enforcing bounds and each has different tradeoffs. Following examples describes +2 protocols, LegoGroth16 and Bulletproofs++. The former is a ZK-SNARK based protocol and has a trusted setup meaning that each verifier +has to do a ZK-SNARK setup (only once, and not per holder or per interaction) and then communicate the setup parameters, called proving key to the holder. +With Bulletproofs++, there is no trusted setup and hence the setup parameters can be generated by anyone. However LegoGroth16 is faster to verify (also has +other benefits like holder being able to reuse generated proofs but that is still present only in the Rust library). + +Common setup for both bound check protocols + +```ts +const jsonSchema1 = CredentialSchema.essential(); +jsonSchema1.jsonSchema[SUBJECT_STR] = { + type: 'object', + properties: { + fname: { type: 'string' }, + lname: { type: 'string' }, + email: { type: 'string' }, + SSN: { $ref: '#/definitions/encryptableString' }, + score: { type: 'number', minimum: -100, multipleOf: 0.1 }, + } +}; +jsonSchema1.properties['issuanceDate'] = { type: 'string', format: 'date' }; +jsonSchema1.properties['expirationDate'] = { type: 'string', format: 'date' }; + +// Signer 1 with keys `sk1`, `pk1`, creates `credential1` +const builder1 = new BBSCredentialBuilder(); +builder1.schema = credSchema1; +builder1.subject = { + fname: 'John', + lname: 'Smith', + email: 'john.smith@example.com', + SSN: '123-456789-0', + score: 55.5, +}; +builder1.setTopLevelField('issuanceDate', '2023-09-14'); +builder1.setTopLevelField('expirationDate', '2025-09-14'); +const credential1 = builder1.sign(sk1); +``` + +Bound check using LegoGroth16 + +```ts +// Verifier does one time setup for ZK-SNARK and then shares the same setup parameters with each holder who wishes to create proofs +const pk = BoundCheckSnarkSetup(); +// snarkProvingKey will be shared with the holder (prover) so compress it to make it shorter. This is not gzip like compression but EC point compression +const snarkProvingKey = pk.decompress(); +// snarkVerifyingKey will be kept by the verifier to verifer the proof +const snarkVerifyingKey = pk.getVerifyingKeyUncompressed(); + +// Holder starts creating presentation +const presBuilder = new PresentationBuilder(); +// PresentationBuilder assigns index 0 to credential1 +console.assert(presBuilder.addCredential(credential1) === 0); + +// Minimum and maximum value of attribute `expirationDate` +const [minExpDate, maxExpDate] = [new Date('2025-12-31'), new Date('2026-12-31')]; +// Minimum and maximum value of attribute `credentialSubject.score` +const [minScore, maxScore] = [40, 85]; + +// paramId is used to let the PresentationBuilder uniquely identify the snarkProvingKey. +// If more than 1 bound check predicate is being proved then the next call to enforceBounds can omit passing snarkProvingKey and just pass paramId +const paramId = 'lg16'; +// Enforce check on attribute expirationDate as minExpDate.toISOString() <= expirationDate < maxExpDate.toISOString() +presBuilder.enforceBounds(0, 'expirationDate', minExpDate.toISOString(), maxExpDate.toISOString(), paramId, snarkProvingKey); +// Enforce check on attribute credentialSubject.score as minScore <= credentialSubject.score < maxScore +presBuilder.enforceBounds(0, 'credentialSubject.score', minScore, maxScore, paramId); + +const pres = presBuilder.finalize(); + +// The verifier checks if the correct bounds have been satisfied. +console.assert( + areBothEqual(pres.spec.credentials[0].bounds, { + credentialSubject: { + score: [{ // Note the array here. This is because multiple bounds can be proven on an attribute + min: minScore, + max: maxScore, + paramId: 'lg16', + protocol: 'LegoGroth16' + }] + }, + expirationDate: [{ + min: minExpDate, + max: maxExpDate, + paramId: 'lg16', + protocol: 'LegoGroth16' + }] +} +)); + +// Verifier passes the snark verification key for the presentation to verify +const pp = new Map(); +// Verifier passes the same paramId +pp.set(paramId, snarkVerifyingKey); +const pks = new Map(); +pks.set(0, pk1); +console.assert(pres.verify(pks, undefined, pp).verified); +``` + +Bound check using Bulletproofs++ -See these [tests](../../tests/anonymous-credentials/presentation.spec.ts) for examples of presentation creation, verification and (de)serialization with use of the above-mentioned features. +```ts +// Holder starts creating presentation +const presBuilder = new PresentationBuilder(); +// PresentationBuilder assigns index 0 to credential1 +console.assert(presBuilder.addCredential(credential1) === 0); + +// Minimum and maximum value of attribute `expirationDate` +const [minExpDate, maxExpDate] = [new Date('2025-12-31'), new Date('2026-12-31')]; +// Minimum and maximum value of attribute `credentialSubject.score` +const [minScore, maxScore] = [40, 85]; + +// Note that no setup params are generated as they will be internally created if not passed. +// Enforce check on attribute expirationDate as minExpDate.toISOString() <= expirationDate < maxExpDate.toISOString() +presBuilder.enforceBounds(0, 'expirationDate', minExpDate.toISOString(), maxExpDate.toISOString()); +// Enforce check on attribute credentialSubject.score as minScore <= credentialSubject.score < maxScore +presBuilder.enforceBounds(0, 'credentialSubject.score', minScore, maxScore); + +const pres = presBuilder.finalize(); + +// The verifier checks if the correct bounds have been satisfied. +console.assert( + areBothEqual(pres.spec.credentials[0].bounds, { + credentialSubject: { + score: [{ // Note the array here. This is because multiple bounds can be proven on an attribute + min: minScore, + max: maxScore, + protocol: 'Bulletproofs++' + }] + }, + expirationDate: [{ + min: minExpDate, + max: maxExpDate, + protocol: 'Bulletproofs++' + }] + } + ) +); + +const pks = new Map(); +pks.set(0, pk1); +console.assert(pres.verify(pks).verified); +``` + +With verifiable encryption, a verifier should be able to check that the holder encrypted certain attributes from his credential +for a 3rd party, say a regulator/auditor, which can decrypt those but not the verifier. This is done using a ZK-SNARK based +protocol called SAVER. Here the 3rd party, the decryptor, does a ZK-SNARK setup, publishes the setup parameters which +are used by the holder and verifier respectively. The holder can encrypt any attributes for any number of decryptors. each having +separate keys + +```ts +// This uses credential1 from previous examples which has a field called SSN which will be encrypted by the holder + +// Setup done by the 3rd party (decryptor) +const chunkBitSize = 16; +const encGens = dockSaverEncryptionGens(); +const [saverSnarkPk, saverSec, encryptionKey, decryptionKey] = SaverDecryptor.setup(encGens, chunkBitSize); +const saverSk = saverSec; +// Needed by the holder (prover) +const saverProvingKey = saverSnarkPk.decompress(); +// Needed by the verifier +const saverVerifyingKey = saverSnarkPk.getVerifyingKeyUncompressed(); +// Needed by both, the holder and verifier +const saverEk = encryptionKey.decompress(); +// Needed by 3rd party to decrypt and verifier to verify the decryption result +const saverDk = decryptionKey.decompress(); + +// Setup done by the verifier and shared with the holder +const ck = SaverChunkedCommitmentKey.generate(stringToBytes('some nonce')); +const commKey = ck.decompress(); + +// To identify different parameters +const commKeyId = 'random-1'; +const ekId = 'random-2'; +const snarkPkId = 'random-3'; + +// Holder starts creating presentation +const presBuilder = new PresentationBuilder(); +// PresentationBuilder assigns index 0 to credential1 +console.assert(presBuilder.addCredential(credential1) === 0); +presBuilder.verifiablyEncrypt( + 0, + 'credentialSubject.SSN', + chunkBitSize, + commKeyId, + ekId, + snarkPkId, + commKey, + saverEk, + saverProvingKey +); + +const pres = presBuilder.finalize(); + +// Verifier checks that the correct encryption key and other parameters were used by the prover +console.assert( + areBothEqual(pres.spec.credentials[0].verifiableEncryptions, { + credentialSubject: { + SSN: [{ // Note the array here. This is because multiple encryption can be done on an attribute + chunkBitSize, + commitmentGensId: commKeyId, + encryptionKeyId: ekId, + snarkKeyId: snarkPkId, + protocol: 'SAVER' + }] + } + }) +); + +// These checks are made by the verifier, i.e. verifier checks that the ciphertext for each required attribute is +// present in the presentation and the presentation is valid. The verifier will preserve the ciphertext to be later +// passed on to the decryptor +// @ts-ignore +console.assert(pres1.attributeCiphertexts.size === 1); + +// Verifier passes the snark verification key and other params for the presentation to verify +const pp = new Map(); +pp.set(commKeyId, commKey); +pp.set(ekId, saverEk); +pp.set(snarkPkId, saverVerifyingKey); + +console.assert(pres.verify(pks, undefined, pp).verified); + +// Verifier extracts the ciphertext from the presentation +const ciphertexts = pres.attributeCiphertexts?.get(0); + +// Decryptor gets the ciphertext from the verifier and decrypts it +let cts = _.get(ciphertexts, 'credentialSubject.SSN') as (SaverCiphertext | SaverCiphertext[]); // Get the ciphertext for attribute credentialSubject.SSN +if (!Array.isArray(cts)) { // As the holder might have encrypted for multiple decryptors + cts = [cts]; +} +cts.forEach((ciphertext) => { + const decrypted = SaverDecryptor.decryptCiphertext(ciphertext, saverSk, saverDk, saverVerifyingKey, chunkBitSize); + // The decrypted message is raw bytes which can be decoded to get the attribute string. + console.assert(MessageEncoder.reversibleDecodeStringForSigning(decrypted.message) === _.get(credential1.subject, 'SSN')); + + // Decryptor shares the decryption result with verifier which the verifier can check for correctness. + console.assert( + ciphertext.verifyDecryption( + decrypted, + saverDk, + saverVerifyingKey, + dockSaverEncryptionGensUncompressed(), + chunkBitSize + ).verified + ); +}); +``` + +For credential revocation, the holder uses accumulator where it can prove membership/non-membership depending on how the revocation is implemented. +Assuming a credential is revocable, i.e. signer called `setCredentialStatus` while signing, following example shows how to use it during presentations. + + +```ts +const builder = new BBSCredentialBuilder(); +// .. +builder.subject = { + // .... attributes +}; + +builder.setCredentialStatus('dock:accumulator:accumId123', MEM_CHECK_STR, 'user:A-123', RevocationStatusProtocol.Vb22); + +const credential = builder.sign(sk); + +const presBuilder = new PresentationBuilder(); +console.assert(presBuilder.addCredential(credential) === 0); + +// Any other predicates .... + +// Holder specifying accumulator witness and value for status of `credential` +presBuilder.addAccumInfoForCredStatus( + 0, // Refers to credential index for whose status this accumulator is being used + accumulatorWitness, // Witness of the accumulator + accumulator.accumulated, // Accumulator value for which the above witness is valid + accumulatorPk, // Public key of the accumulator + { // This is optional information and can be used to indicate timestamp of the accumulator being used, here it refers to the block number (of the blockchain where the accumulator is hosted) corresponding to the accumulator value. + blockNo: 2010334 + } +); +const pres = presBuilder.finalize(); + +// This check is made by the verifier, i.e. verifier checks that the accumulator id, type, value and timestamp (`blockNo`) +// are as expected +console.assert(areBothEqual(pres.spec.getStatus(0), { + id: 'dock:accumulator:accumId123', + [TYPE_STR]: VB_ACCUMULATOR_22, + revocationCheck: MEM_CHECK_STR, + accumulated: accumulator.accumulated, + extra: { blockNo: 2010334 } +})); + +const acc = new Map(); +acc.set(0, accumulatorPk); +console.assert(pres.verify([pk], acc).verified); +``` + +For more complex predicates, they can be specified using Circom (see the main Readme for the Circom workflow, R1CS files, WASM files, etc). + +```ts +const builder = new BBSCredentialBuilder(); +// .. +builder.subject = { + // .... attributes +}; +const credential = builder.sign(sk); + +const presBuilder = new PresentationBuilder(); +console.assert(presBuilder.addCredential(credential) === 0); + +presBuilder.enforceCircomPredicate( + 0, // Refers to credential index 0 + [['x', 'credentialSubject.education.grade']], // An array of pairs for private variables of the circuit. The first item of pair the variable name and second is the attribute it corresponds to. + [['set', publicValue]], // An array of pairs for public variables of the circuit. The first item of pair the variable name and second is the value it corresponds to. + circuitId, // Identifier of the circuit. Useful as multiple circuits can be used in a presentation or same circuit can be used for multiple predicates + pkId, // Identifier of the proving key for the circuit + r1cs, + wasm, + provingKey +); + +// Above uses a single circuit for predicates over a single credential. Its possible to use a single circuit with several credentials, +// i.e. some variable of circuit correspond to one credential, some to another and so using `enforceCircomPredicateAcrossMultipleCredentials` + +const pres = presBuilder.finalize(); + +// Verifier should check that the spec has the required predicates and also check the variable names are mapped +// to the correct attributes or public values for private and public variables respectively +console.assert(pres.spec.credentials[0].circomPredicates?.length === 1); +console.assert(pres.spec.credentials[0].circomPredicates[0].privateVars.length === 1); +console.assert(areBothEqual(pres.spec.credentials[0].circomPredicates[0].privateVars[0], { + varName: 'x', + attributeName: { credentialSubject: { education: { grade: null } } } +} +)); +console.assert(pres.spec.credentials[0].circomPredicates[0].publicVars.length === 1); +console.assert(pres.spec.credentials[0].circomPredicates[0].publicVars[0].varName === 'set'); +console.assert(areBothEqual(pres.spec.credentials[0].circomPredicates[0].publicVars[0].value, publicValue)); + +const pp = new Map(); +pp.set(pkId, verifyingKey); +pp.set(PresentationBuilder.r1csParamId(circuitId), getR1CS(r1cs)); +pp.set(PresentationBuilder.wasmParamId(circuitId), wasm); + +// Set output variable for circuit. +const circomOutputs = new Map(); +circomOutputs.set(0, [[publicValue]]); +console.assert(pres.verify([pk], undefined, pp, circomOutputs).verified); +``` + +See [these](../../tests/anonymous-credentials/presentation.spec.ts) [tests](../../tests/anonymous-credentials/presentation-circom.spec.ts) for examples of presentation creation, verification and (de)serialization with use of the above-mentioned features. ## Blinded Credentials @@ -66,6 +964,203 @@ on the credential attribute, etc. Any predicate supported in `Presentation`s can Predicates can also be proven over the blinded attributes, eg, `markBlindedAttributesEqual` can be used to prove some blinded attribute equal to a credential attribute, `verifiablyEncryptBlindedAttribute` can be used to verifiably encrypt a blinded attribute, etc. +Holder requesting a credential with some attributes blinded and proves some predicates about the blinded attributes + +```ts +// Holder and issuer should know the schema for credential +const schema = CredentialSchema.essential(); +schema.properties[credentialSubject] = { + type: 'object', + properties: { + fname: { type: 'string' }, + lname: { type: 'string' }, + sensitive: { + type: 'object', + properties: { + email: { type: 'string' }, + phone: { type: 'string' }, + SSN: { $ref: '#/definitions/encryptableString' } + } + }, + education: { + type: 'object', + properties: { + studentId: { type: 'string' }, + university: { + type: 'object', + properties: { + name: { type: 'string' }, + registrationNumber: { type: 'string' } + } + }, + transcript: { + type: 'object', + properties: { + rank: { type: 'integer', minimum: 0 }, + CGPA: { type: 'number', minimum: 0, multipleOf: 0.01 }, + scores: { + type: 'object', + properties: { + english: { type: 'integer', minimum: 0 }, + mathematics: { type: 'integer', minimum: 0 }, + science: { type: 'integer', minimum: 0 }, + history: { type: 'integer', minimum: 0 }, + geography: { type: 'integer', minimum: 0 } + } + } + } + } + } + } + } +}; +const credSchema = new CredentialSchema(schema); + +// These are the attributes holder wants to hide from issuer +const blindedSubject = { + sensitive: { + email: 'john.smith@example.com', + SSN: '123-456789-0' + }, + education: { + studentId: 's-22-123450', + university: { + registrationNumber: 'XYZ-123-789' + } + } +}; + +// Holder creates the request to get a blinded credential +const reqBuilder = new BBSBlindedCredentialRequestBuilder(); +reqBuilder.schema = schema; +reqBuilder.subjectToBlind = blindedSubject; + +// Holder proves some predicates about the blinded attributes. These will be demanded by the issuer +reqBuilder.enforceInequalityOnBlindedAttribute('credentialSubject.sensitive.email', 'alice@example.com'); +reqBuilder.enforceInequalityOnBlindedAttribute('credentialSubject.sensitive.SSN', '1234'); + +// Finalize the builder to get the blinded credential request. Note that in case of BBS+ or BDDT16, `finalize` will +// return a blinding as well which will be used to unblind the blinded credential to get a normal credential. This +// request is sent to the issuer +const blindedCredRequest = reqBuilder.finalize(); + +// Issuer checks that the desired conditions have been enforced. +console.assert(areBothEqual(blindedCredRequest.presentation.spec.blindCredentialRequest.attributeInequalities, { + credentialSubject: { + sensitive: { + email: [ + { inEqualTo: 'alice@example.com', protocol: 'Uprove' }, + ], + SSN: [{ inEqualTo: '1234', protocol: 'Uprove' }] + } + } + }) +); + +// Issuer checks the cryptographic validity of the request. Note the empty map. This is because while requesting the blinded credential, +// the user is not presenting other credentials as well. This will be seen in next example +console.assert(blindedCredRequest.verify(new Map()).verified); + +// Issuer start building the blinded credential +const blindedCredBuilder = req.generateBlindedCredentialBuilder(); +// Issuer knows these attributes. These are called unblinded attributes +blindedCredBuilder.subject = { + fname: 'John', + lname: 'Smith', + education: { + university: { + name: 'Example University' + }, + transcript: { + rank: 100, + CGPA: 2.57, + scores: { + english: 60, + mathematics: 70, + science: 50, + history: 45, + geography: 40 + } + } + } +}; +// Issuer finally signs to create the blinded credential. This will be sent to the holder +const blindedCred = blindedCredBuilder.sign(sk); + +// Holder creates a normal credential from the blinded credential. For BBS+ or BBDT16, holder would have used the blinding +// returned during `reqBuilder.finalize` and passed to `blindedCred.toCredential` +const credential1 = blindedCred.toCredential(blindedSubject); +// This credential can be verified with signer's public key +credential1.verify(pk) +``` + +An issuer might demand a presentation from another credential before issuing a blinded credential. Eg. before issuing blinded +credential `credential2`, issuer needs a presentation from `credential1` (along with any predicates). Following shows that +holder while requesting a blinded credential, shares a presentation from another credential, `credential1` and also proves that certain +attributes of `credential1` and the blinded credential `credential2` are same. + +```ts +// The holder already has credential1 from the previous example + +const blindedSubject = { + email: 'john.smith@example.com', + SSN: '123-456789-0', + userId: 'user:123-xyz-#', + secret: 'my-secret-that-wont-tell-anyone' +}; + +// Holder creates the request to get a blinded credential +const reqBuilder = new BBSBlindedCredentialRequestBuilder(); +reqBuilder.schema = schema2; // some schema for new credential2 +reqBuilder.subjectToBlind = blindedSubject; + +// Holder shares a presentation of a credential along with blinded credential request. Any number of credential could be added +console.assert(reqBuilder.addCredentialToPresentation(credential1) === 0); + +// Reveal some attributes from credentail1 +reqBuilder.markCredentialAttributesRevealed( + 0, + new Set([ + 'credentialSubject.education.university.name', + 'credentialSubject.education.university.registrationNumber' + ]) +); + +// Prove that credentialSubject.SSN attribute of credentail1 is same as the credentialSubject.sensitive.SSN blinded attribute +reqBuilder.enforceEqualityOnBlindedAttribute( + [ + 'credentialSubject.SSN', + [ + [0, 'credentialSubject.sensitive.SSN'] // 0 refers to credential1 + ] + ] +); +// Prove that credentialSubject.email attribute of credentail1 is same as the credentialSubject.sensitive.email blinded attribute +reqBuilder.enforceEqualityOnBlindedAttribute( + [ + 'credentialSubject.email', + [ + [0, 'credentialSubject.sensitive.email'] // 0 refers to credential1 + ] + ] +); + +// More predicates could be satisfied on credential1 as +// reqBuilder.enforceBoundsOnCredentialAttribute(0, 'credentialSubject.education.transcript.CGPA', minCGPA, maxCGPA); +// ... + +const blindedCredRequest = reqBuilder.finalize(); + +const pks = new Map(); +pks.set(0, pk1); +console.assert(blindedCredRequest.verify(pks).verified); + +// Issuer start building the blinded credential +const blindedCredBuilder = req.generateBlindedCredentialBuilder(); + +// Issuer sets the known attributes, creates the blinded credential and holder unblinds the blinded credential, as in the example before +``` + See these [tests](../../tests/anonymous-credentials/blind-issuance.spec.ts) for examples of using these predicates. ## KVAC Credentials @@ -84,8 +1179,57 @@ public key but instead supports `verifyUsingValidityProof` method which requires that can be created by the signer. Unlike regular credentials, `BBDT16Credential` contain a [MAC](https://en.wikipedia.org/wiki/Message_authentication_code) and not a signature which require the secret key for verification. +In cases where the verifier does not trust the signer to communicate the result of verification of `KeyedProof` honestly, i.e. it suspects +that the signer might report `KeyedProof` to be invalid when its valid or vice versa. In that case, the verifier can request the signer to +provide a proof of validity or proof of invalidity of the `KeyedProof` by calling `proofOfValidity` or `proofOfInvalidity` + This principle also applies to credential revocation (`status` field) where the revocation status can only be checked by the issuer. +```ts +const params = BBDT16MacParams.generate(1, BBDT16_MAC_PARAMS_LABEL_BYTES); +// Credential signature works as with other schemes +const credential1 = builder.sign(sk); + +// As KVAC credentials can't be direcly verified using the public key, signer creates a proof of validity of credential and gives to the holder +const proof = credential1.proofOfValidity(sk, pk, params); +// Holder verifies the proof to be assured of the credential validity +console.assert(credential1.verifyUsingValidityProof(proof, pk, params).verified); + +// Holder creates presentation as usual, adds predicates, etc as usual +const presBuilder = new PresentationBuilder(); +// PresentationBuilder assigns index 0 to credential1 +console.assert(presBuilder.addCredential(credential1) === 0); +// .... +const pres = presBuilder.finalize(); + +// Now there are 2 possibilities, either the verifier is same as the signer (or verifier knows the secret key) or +// verifier extracts KeyedProof from the presentation and takes it to the signer who can then verify it using the secret key. + +// Verifier is same as the signer +const pks = new Map(); +pks.set(0, sk); // Notice its passing the secret key for verification +console.assert(pres.verify(pks).verified); + +// Verifier doesn't have secret key and extracts the KeyedProof +const keyedProofs = pres.getKeyedProofs(); + +// Get KeyedProof for credential at index 0 +const keyedCredProof = keyedProofs.get(0); + +// Now signer uses his secret key to verify the keyed proof +console.assert(keyedCredProof?.credential?.sigType === 'Bls12381BBDT16MACDock2024'); +console.assert(keyedCredProof?.verify(sk).verified); + +// Signer create a proof of validity of the keyed-proof and gives to the verifier +const pv = proof.proofOfValidity(sk, pk, params); +// Verifier checks the proof and is convinced that the signer reported the verification result correctly +console.assert(pv.verify(proof, pk, params).verified); + +// KeyedProof can be serialized/deserialized from JSON. +let j = keyedCredProof.toJSON(); +let recreated = KeyedProof.fromJSON(j); +``` + See these [tests](../../tests/anonymous-credentials/keyed-proofs.spec.ts) for examples. *Note that lot of classes mentioned above are abstract as this project supports multiple signature schemes.* diff --git a/src/anonymous-credentials/blinded-credential-builder.ts b/src/anonymous-credentials/blinded-credential-builder.ts index 84bd5238..6e90da04 100644 --- a/src/anonymous-credentials/blinded-credential-builder.ts +++ b/src/anonymous-credentials/blinded-credential-builder.ts @@ -17,9 +17,9 @@ import { BBDT16BlindMac, BBDT16MacParams, BBDT16MacSecretKey } from '../bbdt16-m * Used by the signer to create a blinded credential. The signer will know only the unblinded attributes */ export abstract class BlindedCredentialBuilder extends CredentialBuilderCommon { - // NOTE: This should match `CredentialBuilder.VERSION` exactly else backward compatibility code won't always work. - // This is because `BlindedCredential.toCredential` outputs a `Credential` which should be same as the one output - // by `CredentialBuilder.sign` + /** NOTE: This should match `CredentialBuilder.VERSION` exactly else backward compatibility code won't always work. + This is because `BlindedCredential.toCredential` outputs a `Credential` which should be same as the one output + by `CredentialBuilder.sign` */ static VERSION = CredentialBuilder.VERSION; blindedCredReq: IBlindCredentialRequest; diff --git a/src/anonymous-credentials/blinded-credential-request.ts b/src/anonymous-credentials/blinded-credential-request.ts index 73621bcb..815aa46b 100644 --- a/src/anonymous-credentials/blinded-credential-request.ts +++ b/src/anonymous-credentials/blinded-credential-request.ts @@ -10,10 +10,10 @@ import { } from './blinded-credential-builder'; /** - * A request for getting a blinded credential. Sent by the user to the signer who will verify it and then sign a blinded credential + * A request for getting a blinded credential. Sent by the user to the signer who will verify it and then sign a blinded + * credential. It contains a presentation which proves predicates about the blinded attributes */ export abstract class BlindedCredentialRequest extends Versioned { - // A blinded credential request will contain a presentation presentation: Presentation; protected constructor(version: string, presentation: Presentation) { diff --git a/src/anonymous-credentials/credential-builder-common.ts b/src/anonymous-credentials/credential-builder-common.ts index 207374d6..f004e8a7 100644 --- a/src/anonymous-credentials/credential-builder-common.ts +++ b/src/anonymous-credentials/credential-builder-common.ts @@ -61,6 +61,14 @@ export abstract class CredentialBuilderCommon extends Versioned { return this._credStatus; } + /** + * Set the `credentialStatus` property of the credential + * @param registryId - This is id of the revocation registry, like the unique id of the accumulator + * @param revCheck - whether its a membership or non-membership check. this depends on how revocation is implemented, i.e. if + * @param memberValue - Value present/absent in the revocation registry (accumulator for now) which corresponds to a credential. + * This should be unique per credential per registry. + * @param revType - revocation protocol being used like if accumulator, which accumulator + */ setCredentialStatus(registryId: string, revCheck: string, memberValue: unknown, revType?: RevocationStatusProtocol) { const rType = revType ? revType : RevocationStatusProtocol.Vb22; if (rType == RevocationStatusProtocol.Vb22) { @@ -104,6 +112,9 @@ export abstract class CredentialBuilderCommon extends Versioned { return v; } + /** + * Serialize the credential making it ready for signing + */ serializeForSigning(): object { // Schema should be part of the credential signature to prevent the credential holder from convincing a verifier of a manipulated schema const s = { diff --git a/src/anonymous-credentials/credential.ts b/src/anonymous-credentials/credential.ts index 611a4616..193b8143 100644 --- a/src/anonymous-credentials/credential.ts +++ b/src/anonymous-credentials/credential.ts @@ -227,6 +227,18 @@ export class BBDT16Credential extends Credential number; * A class extending `BytearrayWrapper` containing instruments for dealing with message encoding/decoding. */ export abstract class MessageEncoder extends BytearrayWrapper { - // The field element size is 32 bytes so the maximum byte size of encoded message must be 32. + /** The field element size is 32 bytes so the maximum byte size of encoded message must be 32. */ static readonly maxEncodedLength = 32; static readonly textEncoder = new TextEncoder(); static readonly textDecoder = new TextDecoder(); @@ -304,17 +304,6 @@ export class Encoder { } encodeDefault(value: unknown, strict = false): Uint8Array { - // if (this.defaultEncoder !== undefined) { - // return this.defaultEncoder(value); - // } else { - // if (!strict && value instanceof Uint8Array) { - // return MessageEncoder.encodeMessageForSigning(value); - // } else { - // throw new Error( - // `Cannot encode value ${value} as neither was default encoder present nor it was an Uint8Array. Its type was ${typeof value}` - // ); - // } - // } return this._encodeDefault(MessageEncoder.encodeMessageForSigning, value, strict) } diff --git a/src/frost-dkg.ts b/src/frost-dkg.ts index 9910a109..efb1ac93 100644 --- a/src/frost-dkg.ts +++ b/src/frost-dkg.ts @@ -19,8 +19,14 @@ import { BBSPlusSignatureParamsG1 } from './bbs-plus'; import { BBSSignatureParams } from './bbs'; import { ThresholdPublicKey } from './threshold-sigs'; +/** + * Message to be sent in round 1 + */ export class Round1Msg extends BytearrayWrapper {} +/** + * Share to be sent in round 2 + */ export class Share extends BytearrayWrapper {} /** @@ -28,29 +34,29 @@ export class Share extends BytearrayWrapper {} * Each participant has a unique integer id > 0 and ids form a contiguous set, i.e. no gaps. Protocol has 2 rounds and * in each round each participant sends message to others */ -export abstract class Participant { - // Id of this participant +export abstract class FrostDkgParticipant { + /** Id of this participant */ readonly id: number; readonly threshold: number; readonly total: number; - // Id of this execution of the DKG. Use different ids in different protocol executions. + /** Id of this execution of the DKG. Use different ids in different protocol executions. */ readonly protocolId: Uint8Array; - // Message to be sent in round 1 + /** Message to be sent in round 1 */ round1Msg?: Round1Msg; - // Shares to be sent in round 2 + /** Shares to be sent in round 2 */ shares?: Share[]; - // Count of messages received from others in round 1 + /** Count of messages received from others in round 1 */ receivedFromInRound1Count?: number; - // Sender ids who sent message in round 2 + /** Sender ids who sent message in round 2 */ receivedFromInRound2?: Set; - // The secret key of the participant + /** The secret key of the participant */ secretKey?: Uint8Array; - // The public key of the participant + /** The public key of the participant */ publicKey?: Uint8Array; - // The threshold public key and all participants will have the same public key + /** The threshold public key and all participants will have the same public key */ thresholdPublicKey?: Uint8Array; private round1State?: Uint8Array; @@ -205,7 +211,10 @@ export abstract class Participant { ) => Uint8Array; } -export class ParticipantG1 extends Participant { +/** + * Participant when the public key is in group G1 + */ +export class FrostDkgParticipantG1 extends FrostDkgParticipant { protected startRound1Func(): ( participantId: number, threshold: number, @@ -247,7 +256,10 @@ export class ParticipantG1 extends Participant { } } -export class ParticipantG2 extends Participant { +/** + * Participant when the public key is in group G2 + */ +export class FrostDkgParticipantG2 extends FrostDkgParticipant { protected startRound1Func(): ( participantId: number, threshold: number, diff --git a/src/index.ts b/src/index.ts index 8b69edf3..cac6030b 100644 --- a/src/index.ts +++ b/src/index.ts @@ -19,3 +19,8 @@ export { getR1CS } from './r1cs/file'; export { processParsedR1CSFile } from './r1cs/file'; export { ParsedR1CSFile } from './r1cs/file'; export * from './keyed-proofs'; +export * from './encoder'; +export * from './bytearray-wrapper'; +export * from './ICompressed'; +export * from './frost-dkg'; +export * from './threshold-sigs'; diff --git a/src/keyed-proofs.ts b/src/keyed-proofs.ts index e071d4bd..996e792a 100644 --- a/src/keyed-proofs.ts +++ b/src/keyed-proofs.ts @@ -56,7 +56,7 @@ export class BBDT16KeyedProof extends BytearrayWrapper { } /** - * Proof of validity of keyed proof of BBDT16 MAC. + * Proof of validity of keyed proof of BBDT16 MAC. This is created by the signer to convince the verifier that the keyed-proof was indeed valid. */ export class ProofOfValidityBDDT16KeyedProof extends BytearrayWrapper { verify(proof: BBDT16KeyedProof, publicKey: BBDT16MacPublicKeyG1, params: BBDT16MacParams): VerifyResult { @@ -65,7 +65,7 @@ export class ProofOfValidityBDDT16KeyedProof extends BytearrayWrapper { } /** - * Proof of invalidity of keyed proof of BBDT16 MAC. + * Proof of invalidity of keyed proof of BBDT16 MAC. This is created by the signer to convince the verifier that the keyed-proof was indeed invalid. */ export class ProofOfInvalidityBDDT16KeyedProof extends BytearrayWrapper { verify(proof: BBDT16KeyedProof, publicKey: BBDT16MacPublicKeyG1, params: BBDT16MacParams): VerifyResult { diff --git a/src/ps/params.ts b/src/ps/params.ts index 8752cf1b..2e0d32d0 100644 --- a/src/ps/params.ts +++ b/src/ps/params.ts @@ -100,7 +100,6 @@ export class PSSignatureParams implements ISignatureParams { * Produces a multi message commitment for the given message using supplied blinding. * @param messages * @param h (from params) - * @param g * @param blinding */ multiMessageCommitment(messages: Uint8Array[], h: Uint8Array[], blinding: Uint8Array): Uint8Array { diff --git a/src/threshold-sigs/base-ot.ts b/src/threshold-sigs/base-ot.ts index aa3c9b4e..f9fe1829 100644 --- a/src/threshold-sigs/base-ot.ts +++ b/src/threshold-sigs/base-ot.ts @@ -20,10 +20,10 @@ export class Responses extends BytearrayWrapper {} export class HashedKeys extends BytearrayWrapper {} -export class Participant { - // Id of this participant +export class BaseOTParticipant { + /** Id of this participant */ readonly id: number; - // Ids of the other participants of the protocol. + /** Ids of the other participants of the protocol. */ readonly others: Set; senderPks?: Map; diff --git a/tests/anonymous-credentials/blind-issuance.spec.ts b/tests/anonymous-credentials/blind-issuance.spec.ts index 759e0492..fe0cc5d4 100644 --- a/tests/anonymous-credentials/blind-issuance.spec.ts +++ b/tests/anonymous-credentials/blind-issuance.spec.ts @@ -304,6 +304,10 @@ skipIfPS.each([true, false])(`${Scheme} Blind issuance of credentials with withS }) it('should be able to request a credential when some attributes are blinded', async () => { + // In practice, an issuer won't just sign a credential without knowing these attributes but this is just to test + // that nested attributes can be blinded as well + + // These are the attributes holder wants to hide from issuer const blindedSubject = { sensitive: { email: 'john.smith@example.com', @@ -316,8 +320,11 @@ skipIfPS.each([true, false])(`${Scheme} Blind issuance of credentials with withS } } }; + + // Holder creates the request to get a blinded credential const reqBuilder = newReqBuilder(schema1, blindedSubject); + // Holder proves some predicates about the blinded attributes. These will be demanded by the issuer const inEqualEmail = 'alice@example.com'; const inEqualEmail2 = 'bob@example.com'; const inEqualSsn = '1234'; @@ -327,6 +334,7 @@ skipIfPS.each([true, false])(`${Scheme} Blind issuance of credentials with withS const [req, blinding] = finalize(reqBuilder); + // Issuer checks that the desired conditions have been enforced. expect(req.presentation.spec.blindCredentialRequest.attributeInequalities).toEqual({ credentialSubject: { sensitive: { @@ -339,13 +347,17 @@ skipIfPS.each([true, false])(`${Scheme} Blind issuance of credentials with withS } }); - checkResult(req.verify([])); + // Issuer verifies the blinded credential request + checkResult(req.verify(new Map())); - checkReqJson(req, []); + checkReqJson(req, new Map()); + // This isn't checked by the issuer. Just testing that request contains the intended blinded attributes checkBlindedAttributes(req, blindedSubject); + // Issuer start building the blinded credential const blindedCredBuilder = req.generateBlindedCredentialBuilder(); + // Issuer knows these attributes. These are called unblinded attributes blindedCredBuilder.subject = { fname: 'John', lname: 'Smith', @@ -599,6 +611,10 @@ skipIfPS.each([true, false])(`${Scheme} Blind issuance of credentials with withS education: { university: { name: 'Example University', registrationNumber: 'XYZ-123-789' } } } }); + expect(req.presentation.spec.blindCredentialRequest.blindedAttributeEqualities).toEqual([ + ['credentialSubject.SSN', [[0, 'credentialSubject.sensitive.SSN']]], + ['credentialSubject.email', [[0, 'credentialSubject.sensitive.email']]] + ]); expect(req.presentation.spec.getStatus(0)).toEqual({ id: 'dock:accumulator:accumId124', [TYPE_STR]: VB_ACCUMULATOR_22, diff --git a/tests/anonymous-credentials/credential.spec.ts b/tests/anonymous-credentials/credential.spec.ts index cfa55cad..b57df4e4 100644 --- a/tests/anonymous-credentials/credential.spec.ts +++ b/tests/anonymous-credentials/credential.spec.ts @@ -26,6 +26,7 @@ import { Credential, CredentialBuilder, Scheme, + Signature, CredentialProofType } from '../scheme'; describe(`${Scheme} Credential signing and verification`, () => { @@ -44,6 +45,9 @@ describe(`${Scheme} Credential signing and verification`, () => { // Check that the credential JSON contains the schema in JSON-schema format checkSchemaFromJson(credJson[SCHEMA_STR], cred.schema); + expect(credJson.cryptoVersion).toEqual(CredentialBuilder.VERSION); + expect(credJson.proof.type).toEqual(CredentialProofType); + // The recreated credential should verify const recreatedCred = Credential.fromJSON(credJson); verifyCred(recreatedCred, pk, sk); @@ -99,14 +103,19 @@ describe(`${Scheme} Credential signing and verification`, () => { const builder = new CredentialBuilder(); builder.schema = credSchema; + // Fails because attribute `lastName` not in schema builder.subject = { fname: 'John', lastName: 'Smith' }; expect(() => builder.sign(sk)).toThrow(); builder.subject = { fname: 'John', lname: 'Smith' }; const cred = builder.sign(sk); verifyCred(cred, pk, sk); - + expect(cred.version).toEqual(CredentialBuilder.VERSION); + expect(cred instanceof Credential).toEqual(true); + expect(cred.signature instanceof Signature).toEqual(true); + const recreatedCred = checkJsonConvForCred(cred, sk, pk); + expect(recreatedCred instanceof Credential).toEqual(true); expect(recreatedCred.subject).toEqual({ fname: 'John', lname: 'Smith' }); // The credential JSON should be valid as per the JSON schema @@ -1333,6 +1342,8 @@ describe(`${Scheme} Credential signing and verification`, () => { expect(ns.jsonSchema[SCHEMA_PROPS_STR][SUBJECT_STR][SCHEMA_PROPS_STR]['someNumber']).toEqual({ type: 'number', minimum: 0.01, multipleOf: 0.01 }); expect(ns.jsonSchema[SCHEMA_PROPS_STR][SUBJECT_STR][SCHEMA_PROPS_STR]['someInteger']).toEqual({ type: 'integer', minimum: -100}); + checkSigningVerificationAndSerialization(builder, sk, pk); + // Schema specifies the type as numeric but credential uses a decimal value schema.properties[SUBJECT_STR] = { type: 'object', diff --git a/tests/anonymous-credentials/keyed-proofs.spec.ts b/tests/anonymous-credentials/keyed-proofs.spec.ts index c298f50f..0f1377ee 100644 --- a/tests/anonymous-credentials/keyed-proofs.spec.ts +++ b/tests/anonymous-credentials/keyed-proofs.spec.ts @@ -32,8 +32,8 @@ import { import { KBUniversalMembershipWitness, KBUniversalNonMembershipWitness -} from '../../src/accumulator/kb-acccumulator-witness'; -import { KBUniversalAccumulator } from '../../src/accumulator/kb-universal-accumulator'; +} from '../../src'; +import { KBUniversalAccumulator } from '../../src'; import { Credential, CredentialBuilder, isKvac, isPS, PublicKey, Scheme, SecretKey } from '../scheme'; import { checkResult } from '../utils'; import { @@ -156,16 +156,28 @@ describe(`Keyed proof verification with BBDT16 MAC and ${Scheme} signatures`, () builder4.setCredentialStatus('dock:accumulator:accumId123', MEM_CHECK_STR, 'user:A-123'); // @ts-ignore credential4 = builder4.sign(skKvac); + // This is just for testing as only signer has secret key verifyCred(credential4, undefined, skKvac); + // Signer creates validity proof + const proof = credential4.proofOfValidity(skKvac, pkKvac); + // Holder checks using validity proof + checkResult(credential4.verifyUsingValidityProof(proof, pkKvac)); + const builder5 = new BBDT16CredentialBuilder(); builder5.schema = schema; builder5.subject = subject; builder5.setCredentialStatus('dock:accumulator:accumId124', MEM_CHECK_KV_STR, 'user:A-124'); // @ts-ignore credential5 = builder5.sign(skKvac); + // This is just for testing as only signer has secret key verifyCred(credential5, undefined, skKvac); + // Signer creates validity proof + const proof1 = credential5.proofOfValidity(skKvac, pkKvac); + // Holder checks using validity proof + checkResult(credential5.verifyUsingValidityProof(proof1, pkKvac)); + // @ts-ignore [, accumulator1Pk, accumulator1, accumulator1Witness] = await setupPrefilledAccum(200, 122, 'user:A-', schema); @@ -276,6 +288,7 @@ describe(`Keyed proof verification with BBDT16 MAC and ${Scheme} signatures`, () expect(keyedCredProof?.credential).toMatchObject({ sigType: SignatureType.Bbdt16 }); + checkResult(keyedCredProof?.credential?.proof.verify(sk) as VerifyResult); } @@ -289,12 +302,19 @@ describe(`Keyed proof verification with BBDT16 MAC and ${Scheme} signatures`, () [REV_CHECK_STR]: MEM_CHECK_KV_STR }); checkResult(keyedCredProof?.status?.proof.verify(accumulator2Sk) as VerifyResult); + + if (!isKvac()) { + checkResult(keyedCredProof?.verify(undefined, accumulator2Sk) as VerifyResult); + } } function check3(keyedCredProof?: KeyedProof) { expect(keyedCredProof?.credential).toMatchObject({ sigType: SignatureType.Bbdt16 }); + + checkResult(keyedCredProof?.verify(skKvac) as VerifyResult); + const proof = keyedCredProof?.credential?.proof as BBDT16KeyedProof; checkResult(proof.verify(skKvac) as VerifyResult); const pv = proof.proofOfValidity(skKvac, pkKvac, paramsKvac); @@ -306,6 +326,8 @@ describe(`Keyed proof verification with BBDT16 MAC and ${Scheme} signatures`, () expect(keyedCredProof?.credential).toMatchObject({ sigType: SignatureType.Bbdt16 }); + checkResult(keyedCredProof?.verify(skKvac, accumulator2Sk) as VerifyResult); + checkResult(keyedCredProof?.credential?.proof.verify(skKvac) as VerifyResult); expect(keyedCredProof?.status).toMatchObject({ [ID_STR]: 'dock:accumulator:accumId124', @@ -331,6 +353,10 @@ describe(`Keyed proof verification with BBDT16 MAC and ${Scheme} signatures`, () checkResult(proof.verify(accumulator3Sk) as VerifyResult); const pv = proof.proofOfValidity(accumulator3Sk, accumulator3Pk, dockAccumulatorParams()); checkResult(pv.verify(proof, accumulator3Pk, dockAccumulatorParams())); + + if (!isKvac()) { + checkResult(keyedCredProof?.verify(undefined, accumulator3Sk) as VerifyResult); + } } function check6(keyedCredProof?: KeyedProof) { @@ -346,6 +372,10 @@ describe(`Keyed proof verification with BBDT16 MAC and ${Scheme} signatures`, () checkResult(proof.verify(accumulator3Sk) as VerifyResult); const pv = proof.proofOfValidity(accumulator3Sk, accumulator3Pk, dockAccumulatorParams()); checkResult(pv.verify(proof, accumulator3Pk, dockAccumulatorParams())); + + if (!isKvac()) { + checkResult(keyedCredProof?.verify(undefined, accumulator3Sk) as VerifyResult); + } } const keyedProofs = presentation.getKeyedProofs(); diff --git a/tests/anonymous-credentials/presentation-multiple-sig-types.spec.ts b/tests/anonymous-credentials/presentation-multiple-sig-types.spec.ts index 98deaf92..7a222bad 100644 --- a/tests/anonymous-credentials/presentation-multiple-sig-types.spec.ts +++ b/tests/anonymous-credentials/presentation-multiple-sig-types.spec.ts @@ -30,13 +30,12 @@ import { BBDT16Credential, BBDT16_MAC_PARAMS_LABEL_BYTES, BBDT16CredentialBuilder, - BBDT16MacProofOfValidity, BBDT16MacPublicKeyG1, BBDT16KeypairG1 + BBDT16MacPublicKeyG1, BBDT16KeypairG1 } from '../../src'; import { checkResult, stringToBytes } from '../utils'; import { checkPresentationJson, getExampleSchema } from './utils'; import { PederCommKey } from '../../src/ped-com'; -import { BBDT16MacParams, BBDT16MacSecretKey } from '../../src/bbdt16-mac'; -import { isKvac } from '../scheme'; +import { BBDT16MacParams, BBDT16MacSecretKey } from '../../src'; describe.each([true, false])( `Presentation creation and verification with withSchemaRef=%s involving credentials with different signature schemes`, @@ -119,8 +118,8 @@ describe.each([true, false])( checkResult(credential.verifyUsingSecretKey(sk)); // Check using validity proof as well - const proof = new BBDT16MacProofOfValidity(credential.signature, skBbdt16, pkBbdt16, paramsBbdt16); - checkResult(credential.verifyUsingValidityProof(proof, pkBbdt16, paramsBbdt16)); + const proof = credential.proofOfValidity(skBbdt16, pkBbdt16); + checkResult(credential.verifyUsingValidityProof(proof, pkBbdt16)); checkResult(credential.verifyUsingValidityProof(proof, pkBbdt16)); } if (sk instanceof BBSSecretKey) { diff --git a/tests/anonymous-credentials/presentation.spec.ts b/tests/anonymous-credentials/presentation.spec.ts index 2b889ede..8d0ca5cf 100644 --- a/tests/anonymous-credentials/presentation.spec.ts +++ b/tests/anonymous-credentials/presentation.spec.ts @@ -818,6 +818,13 @@ describe.each([true, false])( } }); + // Verifier checks that the desired attribute are proved equal + expect(pres4.spec.attributeEqualities).toEqual([ + [[0, 'credentialSubject.SSN'], [1, 'credentialSubject.sensitive.SSN']], + [[0, 'credentialSubject.city'], [1, 'credentialSubject.location.city']], + [[0, 'credentialSubject.height'], [1, 'credentialSubject.physical.height']] + ]); + if (!isKvac()) { // Public keys in wrong order expect(pres4.verify([pk2, pk1]).verified).toEqual(false); diff --git a/tests/anonymous-credentials/schema.spec.ts b/tests/anonymous-credentials/schema.spec.ts index 16d322ba..30925f7d 100644 --- a/tests/anonymous-credentials/schema.spec.ts +++ b/tests/anonymous-credentials/schema.spec.ts @@ -1038,15 +1038,10 @@ describe('Credential Schema', () => { cs = new CredentialSchema(schema); } const j = cs.toJSON(); - // expect(CredentialSchema.convertToDataUri(cs.jsonSchema)).toEqual(j[ID_STR]); - // expect(CredentialSchema.convertFromDataUri(j[ID_STR])).toEqual(cs.jsonSchema); if (withSchemaRef) { expect(j[ID_STR]).toEqual(schemaRef); expect(cs.fullJsonSchema).toEqual(schema); expect(cs.jsonSchema).toEqual(nonEmbeddedSchema); - // @ts-ignore - // expect(CredentialSchema.convertToDataUri(cs.fullJsonSchema)).toEqual(j[FULL_SCHEMA_STR]); - // expect(CredentialSchema.convertFromDataUri(j[FULL_SCHEMA_STR])).toEqual(cs.fullJsonSchema); } else { expect(j[ID_STR]).toEqual(EMPTY_SCHEMA_ID); expect(cs.jsonSchema).toEqual(schema); diff --git a/tests/anonymous-credentials/serialized-objects/bbdt16-presentation-0.10.0.json b/tests/anonymous-credentials/serialized-objects/bbdt16-presentation-0.10.0.json index 40a93502..1593d427 100644 --- a/tests/anonymous-credentials/serialized-objects/bbdt16-presentation-0.10.0.json +++ b/tests/anonymous-credentials/serialized-objects/bbdt16-presentation-0.10.0.json @@ -1 +1 @@ -{"version":"0.10.0","nonce":null,"spec":{"credentials":[{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"},\"email\":{\"type\":\"string\"},\"fname\":{\"type\":\"string\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"lname\":{\"type\":\"string\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"secret\":{\"type\":\"string\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lname":"Smith"}},"bounds":{"credentialSubject":{"timeOfBirth":[{"min":1662010838000,"max":1662010856123,"paramId":"random","protocol":"LegoGroth16"}],"BMI":[{"min":10,"max":40,"paramId":"random","protocol":"LegoGroth16"}],"score":[{"min":-40.5,"max":60.7,"paramId":"random","protocol":"LegoGroth16"}]}},"verifiableEncryptions":{"credentialSubject":{"SSN":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}},"sigType":"Bls12381BBDT16MACDock2024"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"isbool\":{\"type\":\"boolean\"},\"lname\":{\"type\":\"string\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"},\"physical\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"secret\":{\"type\":\"string\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"}},\"type\":\"object\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","location":{"country":"USA"}}},"verifiableEncryptions":{"credentialSubject":{"sensitive":{"userId":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}}},"sigType":"Bls12381BBDT16MACDock2024"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialStatus\":{\"properties\":{\"id\":{\"type\":\"string\"},\"revocationCheck\":{\"type\":\"string\"},\"revocationId\":{\"type\":\"string\"},\"type\":{\"type\":\"string\"}},\"type\":\"object\"},\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"lessSensitive\":{\"properties\":{\"department\":{\"properties\":{\"location\":{\"properties\":{\"geo\":{\"properties\":{\"lat\":{\"minimum\":-90,\"multipleOf\":0.001,\"type\":\"number\"},\"long\":{\"minimum\":-180,\"multipleOf\":0.001,\"type\":\"number\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"lname\":{\"type\":\"string\"},\"rank\":{\"minimum\":0,\"type\":\"integer\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"phone\":{\"type\":\"string\"},\"very\":{\"properties\":{\"secret\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lessSensitive":{"location":{"country":"USA"},"department":{"location":{"name":"Somewhere"}}}}},"status":{"id":"dock:accumulator:accumId123","type":"DockVBAccumulator2022","revocationCheck":"membership","accumulated":"5iYSR7j6eCT2nvmKMGE3f88CQ73crNhcesj1Nq6JwkqbvCzuyR9qNYWLpvyJU1h27d","extra":{"blockNo":2010334}},"bounds":{"credentialSubject":{"lessSensitive":{"department":{"location":{"geo":{"lat":[{"min":-30,"max":50,"paramId":"random","protocol":"LegoGroth16"}],"long":[{"min":-10,"max":85,"paramId":"random","protocol":"LegoGroth16"}]}}}}}},"sigType":"Bls12381BBDT16MACDock2024"}],"attributeEqualities":[[[0,"credentialSubject.SSN"],[1,"credentialSubject.sensitive.SSN"],[2,"credentialSubject.sensitive.SSN"]],[[0,"credentialSubject.timeOfBirth"],[1,"credentialSubject.timeOfBirth"]],[[0,"credentialSubject.BMI"],[1,"credentialSubject.physical.BMI"]],[[0,"credentialSubject.score"],[1,"credentialSubject.score"]],[[0,"credentialSubject.userId"],[1,"credentialSubject.sensitive.userId"]]],"boundedPseudonyms":{},"unboundedPseudonyms":{}},"proof":"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","attributeCiphertexts":{"0":{"credentialSubject":{"SSN":["JNqSkCUAQ8nECey9swz93Q3173czv8B2M7g9diEzLxyWMVPL4Mdei8qGafWnu5vVwTs4Utrh6GCvgUgbMsNePHabnYZw2mejQoDefBi2Q1sdnBwVrFAqgAvPiYUKNr7du2PrmRrA5yHCMJY6WCshBN7wmswhh7eKjMZRe7H3svNqDbuAJd1ygVaXHH6sh6Jia78pU7vaoVLfiafXtScFWE2B2ujdHTjqbgFT5CrsrC8mr9ohG6u7P1UKrkfDXpyqDcMMYiXZ3C2DUuXmQtT2j8eG5szBGd7UNPP5fuVRKxXiVJTVwPHZxVkmhfjjHwnUTY5cQRVeSq38hVdV3EGte9TbghoWipiPjYHLDCKR8pizhBjxdfJ1PS26JiZgJN1jvUcmVX7P45nZwi3odP4A2YKKMq1KBZNVVMnLUsThVvVMbMpNBHtv9akSVcXBZqP82C5totj6TdoCSGPeUExRhZRw9kAtJXz6akVmn1MoBEvk2hwxLjqiWZJUyeZ7v3khrzNzsC23rgfU8Gc49azMb9h8WYaAWM5ju1FW3J1dj3NukBpATEWxbrdjRWNuiAhYgnzhbBjnNwqAQDacH65T9PFNykXVLR39GYSLkJqyapR8c9z5BRrL7N2S7dLU8ztwmVnohT83ajCSkoL1Rdo8xqVwFp3X3ds97iMNd92W1vw9aEZgUoxyKvsDtPhUPtNdoVTqaU313KEWTL7kCyBR5dWCSZA67YsbwGgx8ZFnQeY7yXHcpuNSQJwFW33SDu53QTxUHkmqp3v81JVAmhhicHohKtnDmAgLNAzbWNnSbDtgMttHEGfaF8zdfYHXvExUqCUbWdh19sQCfsYbCP1aW4FGA28ftzwjeom7J5UJuy3N7K3zzqHgfss7M9Nfk1Tv2n6qVhMM286FGCDo8ZZNqQmXPNqp9t2X27g9EGiX8feE7Zy7nQZhwLWPdrkjaMuRtWX17GeSnzyJdhDwKwB8RGgiuhSBbtehcRbxxxRj7qAVaLhH2N1VQUYF5gJVaSDGvCX7nGmXBgQe1ktoRRnC2w5aQjJTJQSt3DD3bCSkfqySg7qNDJAjAfcAaPRNsbfs6DSPqCLv4ErVwWVBfmavbnRkgVibreUA3ZCojNs1kpqcmauE1HB4GxkXRzQjHdw3cPUyem5HsmDiGosatA3dFdw1LHH6eYw2b91opA3"]}},"1":{"credentialSubject":{"sensitive":{"userId":["NJUt3jnGs3MNk1Y2RCbQUDuiusTNGz24Zbh3yraHPZAbEPCWt8YcY8HoYpDQZKFCavknNVQWMwTwQvtppLPMfgHEknULELbppy4CiS6EMtAUC4oyssxCD6BdMZi59MD4CE83hW8fZaV7UXfcCCJrUnJ21M8Sm7ZPqUSLnEXvPcLeagecYmTLh8xmC8xN41CSUrZE9DyuKiyxKzUcDvSEdSA2LEZYoyXVM9FZoEQCQn3CeB5FcVwRqR9e3tFFBeVAFGuVHYMcvThuGrxLUjonSULPLmmxVngwjt6rPgp2egjwqxKaCrDWQny8aqov6sEigkmvXgTc2p9sm3KC6jCfrRRG9kvJFZL6YXmcGeBz2F8FHV6tSdCJJjsGr9TdjJivQHioQpsNCmc6u9ttWSJ6qJFk8ZNH8BHxyhf1Wg4fkjXMoVjuDNaSzTNuaT7bLaw1ejYNZqzU741xhkkVxbyCssUED9JpvR4o96LhZZdbT7tMnFhpJJf3GW9EC3ir7MsvLpZ8fsUAYQ4hHzZZ9PRSX4DWircDsBMH4ohKbCF9Jhuiogi9mydZxCjCAhzs3Gd4y7DvzmKSXPxKSh59JgUVVgKd8bCwWD1kykQLdetR5BDShh8P7s41WsS5VA2PHzVGmPTybrL9fyDF2wuk9ZZWyPERirtt3MxSHkdJhvzM7yWopQhT3qhTgYFikjPaYur6YX8HzxD1XNX8A76PFtmbXZQ1A8hTBTcQLTJApyh6vy3MFfsnWrMdqF9FAb6wMdHCKDF694xWSJhZunYeRzUs67sVeon48sk1gH1jdFKy2aFBcxCsVDtXNYnLjr7PxXywdMYnyj476675JoG8puVuxe1rwZzsdqGuLvgQNLMiNuuarcd3uiGapq5dEZdSjVSqSGYdzNfeFS55pn2i2NuAUohjwiVGNkWuRnPcHDLFeo1fwWFZpNwpX5fwGi5v22yQSJAgUagQDmVCgZTsrLPztVtSoEMcCX6RkY4hBwGjvrUFgvyHG12CXG1Hc3ozEDqMv7PB1x6M2fLgiQXwgoBiVZyeCTiYKDGr455Z8qFzor7h8VRLusjfdcfufcwXrGof5QQrpgUmU7826Cz6gue75fhv98EmLFYKKVLnnXNvjH29qh7eWKwy98bQjNNxnrafB2djKeqZQJ3LZrkERmzvsSPvZ4xsQjByzJpQ1bM"]}}}}} \ No newline at end of file +{"version":"0.10.0","nonce":null,"spec":{"credentials":[{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"},\"email\":{\"type\":\"string\"},\"fname\":{\"type\":\"string\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"lname\":{\"type\":\"string\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"secret\":{\"type\":\"string\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lname":"Smith"}},"bounds":{"credentialSubject":{"timeOfBirth":[{"min":1662010838000,"max":1662010856123,"paramId":"random","protocol":"LegoGroth16"}],"BMI":[{"min":10,"max":40,"paramId":"random","protocol":"LegoGroth16"}],"score":[{"min":-40.5,"max":60.7,"paramId":"random","protocol":"LegoGroth16"}]}},"verifiableEncryptions":{"credentialSubject":{"SSN":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}},"sigType":"Bls12381BBDT16MACDock2024"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"isbool\":{\"type\":\"boolean\"},\"lname\":{\"type\":\"string\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"},\"physical\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"secret\":{\"type\":\"string\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"}},\"type\":\"object\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","location":{"country":"USA"}}},"verifiableEncryptions":{"credentialSubject":{"sensitive":{"userId":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}}},"sigType":"Bls12381BBDT16MACDock2024"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialStatus\":{\"properties\":{\"id\":{\"type\":\"string\"},\"revocationCheck\":{\"type\":\"string\"},\"revocationId\":{\"type\":\"string\"},\"type\":{\"type\":\"string\"}},\"type\":\"object\"},\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"lessSensitive\":{\"properties\":{\"department\":{\"properties\":{\"location\":{\"properties\":{\"geo\":{\"properties\":{\"lat\":{\"minimum\":-90,\"multipleOf\":0.001,\"type\":\"number\"},\"long\":{\"minimum\":-180,\"multipleOf\":0.001,\"type\":\"number\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"lname\":{\"type\":\"string\"},\"rank\":{\"minimum\":0,\"type\":\"integer\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"phone\":{\"type\":\"string\"},\"very\":{\"properties\":{\"secret\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lessSensitive":{"location":{"country":"USA"},"department":{"location":{"name":"Somewhere"}}}}},"status":{"id":"dock:accumulator:accumId123","type":"DockVBAccumulator2022","revocationCheck":"membership","accumulated":"5iYSR7j6eCT2nvmKMGE3f88CQ73crNhcesj1Nq6JwkqbvCzuyR9qNYWLpvyJU1h27d","extra":{"blockNo":2010334}},"bounds":{"credentialSubject":{"lessSensitive":{"department":{"location":{"geo":{"lat":[{"min":-30,"max":50,"paramId":"random","protocol":"LegoGroth16"}],"long":[{"min":-10,"max":85,"paramId":"random","protocol":"LegoGroth16"}]}}}}}},"sigType":"Bls12381BBDT16MACDock2024"}],"attributeEqualities":[[[0,"credentialSubject.SSN"],[1,"credentialSubject.sensitive.SSN"],[2,"credentialSubject.sensitive.SSN"]],[[0,"credentialSubject.timeOfBirth"],[1,"credentialSubject.timeOfBirth"]],[[0,"credentialSubject.BMI"],[1,"credentialSubject.physical.BMI"]],[[0,"credentialSubject.score"],[1,"credentialSubject.score"]],[[0,"credentialSubject.userId"],[1,"credentialSubject.sensitive.userId"]]],"boundedPseudonyms":{},"unboundedPseudonyms":{}},"proof":"AEpHLgUjzKwQn1B2mzyn6jywqHH87YF5BAHJNXYgJWSCV4fYZMCD4K6J2jcDF3eZEG8ajmPVQxrG2kGUJ5FFyeUwb1uqWBLnZ8mr7yfBSG5GkLxZAVd89dYaqmqJ3fF1TuaCVwdwwhyrQVzHbHLnHjJ7BemDFqkPXbkockPtD8oDfvzbmNfJkibqmNbbE3mpdDKgs82gcjC62tMgXswQA1rTNBLpX8GzCdtMsezjN7zumNZ5NwSFFHYAkqZLvwjdC6MUnF5stGXEPogZ48XM8xiC1zZdUmM4bfUVGvLYQRHrdYcqy9Cfw3SEBHnrUyy48g7oh3TdmDGvJeFPnwx26LQCB6cn1WwAmychcxjusY6Z6Shj3Dw1Ci8rxhCuKS2BzxR7B5VBr3jpXoKY8qCThVcFrsnaF7AtE57dSi6h9wd7FqbbgnKHvdmt3HEzu37i8ct9Duj4M2BFUJWWGV18QqiDF4c35VTCPvTEXcPs3X4GtbUsEv5n2nmChTsBgyxGEJDvoGhFXjL2bSWNhZeVNpFxFyv95zjj8HeRGRLVtEa5UE75KoiBYUwKuocR2UPPQGpqUc4z3D8NyKxb1F8FjtywKupwnZ83v9hgYQZ29MEVqvccW7SSRHLy2mxhqBCQfVfMufCG7HkqYDw2WirGf5vBeagG5LMth1rYUzUWqCdqn4wnggxKTpnbjMCfdoNmdZTjWDrzJZSz4D8DLo96vQsgMqaZaKDgre2WHUhUDnn7UEfDp2GwQkSCd738a1A6HBcvhfbvNNZMJSuGZzvzYqYngWGCAhdqGKfmNJrW5NQTPYfDspcZejSNuDXXW8U8SnFdcnk8gZjQGX748RKpTKW9MX9Nw3oiv2q2cCrcoKkLEgzfVTkeiTChdLUk6GkS7UmqrGoYUYzWLDraa1KYDh2KnSySdVmWToRHRhvr7NJdg7k84GtgHMBeqShxVvYT2cuy8UMrDzCXP1ztiyRSEeDjxBftLxe8nLCSazh81WKDK7EtPCxa7P2T5iE3jjrwNFx8tVbWHkTrdYqzLFyBjALSuChcjqHFggixJoNWZsyrNMxqJepg93czhmSUo7Ru2Zcx3NqAZzznnKA5cLFiJXSV62JYSFK3XmLd3rQZFwS7oKbNNczB212pxjGBjMuaZBXr1Zag8Lx6Y4PxVp87G7SXJheAu1ttRJVRdY17qtSG4jLuGacReAFR35eqPZV7YBauYoNZNuqPAhkwyWV8AkxiHsUkYxfDvKcLKiyEtYUZaKkPXpp2CveFiWUq1aVtFKWD4USNm2JeXX31rX9v8VmwiBepjE3G8dc4T7eFAbmgJMYeAvdvR7hRJkdbnGfAEvxzvgsCd9yYtMbxFxbVy7GsVVh6naHfETq3AmgXn8hbmt1zn18HrtMtJrfMcP3YeyAWYTYqh7HgND63kQPd5ZKiYJtFnUHghwC3RuhyYiJTurw9QeVULGHUEZaE8cLPpt9bSbyGGEvT8ourpUQsFno69rKHxPqNScVmegogGgYzqo2de7kJQo2aSjqYMfAAaGPfu7KhYsdVGEqjevs6mNAYxPYsokieJEGcs4dya3YyDxph7XzjpCUrh4HDQiMozjtLkanh8mu34gMvz48VaK8iye3mLN2Yngg6EQdCvvTu2ihCapsRt2TgFV6RG1ouqiHFPaiGRmQSWM1BfMZdnX9RrcbGKyTitiBDVENwe65yyMUoNHNnjXJVwKe1AuQFTJV7tpFvYkuz3SLRGyaL3g3hZy1XnRoHBvu2XfEKcp85ufvfrfG6FScDx2ykmc9t3MJivPcpnBDt9mS5ahSQbnow2bVeLJnZsjALPRYbfdMumquRN5FYHKRZZjT2JcsbzJHmyTK8XE2yfAgC7kBKVNXfqdzkCRSqXHppHmJ2K9kokbvi9YLVXQmUtkLwntpaDLgaLiKhgsKDPGot3HSy2yVXiBfedG2eLQ5L38NTQP4k49jvgh3e7TRy6mALyxXeYB1fpEYUXgtzKFFqUEsU7W82aFu93ijizeo8mXZSDsQCa6cERXz4SrSMU4ehPDaeRVERRotGrQsF9bBaPjEBVGt1SF7S9tRgxXcgRDzGheWAaoknHej3ojchPAAbqPKDJmXBj7Gzr9arKWZWGm1SGs9o7jrhkpBoCLf2Aii7DVDZKf97kacgZBVA4p9K7VaCZBojvGzxF4yZKghN3pYyWtBqAiEkRrvQDM7WA5qjEsBcjHZDMCNeq9nirD2DrBtgbMNz5oqfC95ZhX1rPQppZNWorpZCf63GcfnWKXyzcRFRVPDWMFyYRRHjuT6oPaHqjmsAua7rcQ1p1kzSsoLD1qfGDoYAsQmhngG4wVfRCz6hiPGQ6pvNgSDEUCXsTrnL1x11g9bHaZdRGpqfPrfEFsrdiKTCod45nuHJCwhNBVHgv9XbrhWrvHBf4UyMq2NSFdHQEGUzdbd4KSFqw2MazKxVT84hMgVJNcLmyBi92DM3vXp65jq8Xy4YJN9GMBmudkm6hwNMKs9NDi2FQB482RXPerY3YeiWDFqZuGqwMp1mjQQCCgXitbBb2ZbaweThny9Ymyq5CL4M8GPn6RWVMp7fjVYGUp3s4dKGNcKNbPx3aQSVf2pG2mSHSYUMnjD5GQDkNm58FPk9RisFbYGNMJrhvCAfD9F5NtYSC66w2YCEA2WT7B6uXMug9rwic55saum7VvAFjCRshRrh8dCw5HVS5iBpeuXFoN7Gtee3oEhx9EitYAvDWudxtxEvgqYjrKvcMxohYo6MyLzJq32C1gYbYdXCJbhPNrWDWdz3mhUh1AKyNozzoE9TJAjaXp6MH8BSK1BM34MgC72phgK1TfEfUEiUezBvwzudJY9wDfi5nPRgftMg1gg4THXWXMz6KFtH73umhRKmSRodpoRhQJHVq1HZwRkerVUyu1PJpSehKr4wJ6E6Lam9psEeSMsTTTm85hUTuKyP4k71JZKm73xofo57rTrgKJiarpP4TsGG5Rdj6SyWYocZK1iHMLH7kCqYQtgUJ2TCaJfeHSsBBu9zxLtNW7y3h3iFF6smaHFfeFXv8AjKJQ7gKmrL7YvicyCqmVCoC4L5rLNyEcDrj6ZxKeq2y52LsBCzBqmV8w7phsr7teJDZVeHgcumKuNkuswjBkHESEEt2s94cpmJLQwHCZSJY1aRiWjgg1GoZ7JhenPALGo4TTU1EZt48JFbvm1UtJoZw8DFqHtqh2EEP6cd2FjMQiXYEDD4tLvRVPqUnGmqdY1KXBdxvo7a1xstjgfgYHS2tQJaL9kRaAwVwrY8ioMhXKyZS3Wj9uPoPaGY7feQQRs5WGsVC7xRmjZTRbFY4SqMWDEQbRXdxh6fzuHCgDbWhNWGPLw9Xan1GJBLTG4j7dNSSHXWc2YSnS5Wc7oRo2DGZsBq44x3oRhBLggZdQhda7vCEmZUHZ6QPJgiNpLUrZXdZMfv44r6PKcfwod348aUo58DiypohxiWDRDHCDyJLRCsNtGFqVXVvF4LZM8mkWn1ja6DBVBf5SEifMoojeCBFzxaTuKKZu9Bm4VtasZ1k3DCJdzpp5NmE6XMjWjkEkYcXkQm8CqWvP5zJKgeAo3oXaytbRDfxxBNW8ZZkHXbhmXtbbpzdyg7ki73Myciu4Nai2uWeNFoP7bgNdjbfZQdfCzPRRtbnwmW62L8P1tmt7C6TsQzrX2ZrHPqSxEDmSkkaxX75fAbir3TtX4tsGCYFHKz8x16iJhT5yRtANS9hgjGqYN1NrFoEzqkKu9bhrYhwsNPQchKZ8ze3jm2SDKmPXq8Gs5ahSmywfhxapayAAASbs6mx6PZBfxdSVyVdFcdzxsvtZcWGqQnHHz2UBK6777YHCGcF7tenPTcRcVCsb9cCzc1sXR7prFeFUP4FFPPWt1n3ddPMvE2mDY4KbwyySf1SdmkSTPERmEK2WHjKX4SzSAMEJoCJSLLk6duKjwB7EGmYLiFaX9ifvRvTrfgyLfWv2yQAM73DkxPxQTQQ6ckqJjQiZtMRiVKFNmHYnDfWcDnkM67BuMbJDS2KaPSKrMyaRshk9TwjUzHgimsvXCD2pNsFXvzqrjR2oQTCB1Lt63tABHNyFGhF1jmJ6n7rGrsg4Upbe5e9mLbF3WAbj6R3o35kxZYqYKAPryTYi47SE9MZxvBGmNUYVkNVKyi6HeDGcFnLPDM4gBMakEKbf5sYU2kQ7To48qyGwMqNV4JKMvJzkXuCiQ1f1B4tSMWnkWd3A9yfpVzzLTkQdrgM5SNVpwGE4gWT7JCa8Xau6d2oYaV9bYygCSthkLCPfgpg7REZT2TqLDEKCeJLWijzEW9Ff5r8BBnv1AckZ5xddRT1UvcaNpbRXFLi3nUhL4Jgujz2gpPaFRzfBo5k4vNK5e8ai6cMoPxjuY5TbTUnhzjZVuH7UYMC1mv1ZtPj3oLNv3dqDEi2X3NDYGgE1yyNpcksbpcWLoST27v3Y2vbbtGtWRTM1TQPquF8wV6cEaay7u4S3Rme9DDPNVwCUeSUTsWupJ6jB5GDFFbTi3wTxWTgq81q51NpBn545dRSncmgCDY7GY8Zf4DC1bTbKVRAMvnyeTWLHn2EpF1z3KEMVHcVZehzYagR6SK6Kk8fSugK4dGHaeh4LCdkhSwy5JXxZLxumZiy9meWxiazfutPfSU89XMyorsrYEekUqW9nPmge3gE7DVuhww5WtWxkczhou2pk6bA5y9UN9uCLC5aQT5FFSZ1AwpHu4yuGciod6sjW2q311Mv2KrWzFBsEcBRvvYgKVoPSnT6vXVE3rPdXyFtiu5qQcxSHsGrd9DG2RWFYPm6AgkhFru15Nr3A94pkcuTdY96cWD1TjojD53jRcP8ieJ6wPnXsKuy6zGCxfPuH7ELQcMoDPgvDQpyG68sLRyGiiJnJeErKdKFYUssFNagnXBdqpthi517FuRvdpBjEMwCznUcWaLosqX3KCATHAjQa4AKvpUFrLtLzr7ejBtJaKSSGJme7MJdj26hXVRPHagewsctiDaUmmXqxbRRKcbcmsNd1vNyHpwSyQvGRTvw9dRhPFDfWwzcx5aqMDaSSRab1KjidK3WbU297WDRbqdC4afn6Vuk734VtKSrgtwK5YBNEwdXYvSXr7J6KYfgkvti6Pgq2RVSTbicEJHcifJiQ9QmGPDsTj7yf5dZsGqmwrAFXxt98fZkUDGMcqPGQxemJYsd5ZpZExbj6HVv1oQgKc18jFx4fAyFD3C1xh3gQCESBYKg8MnZmd3jVFjUw9xDidKFbmZkyJsriGdJk3Mhzi5KuGW8RNbJaCFexpbxjeRemSirprd3JQwSiNPGyY6FQjkSLKh39Vm8RmGV4w6rCF9NqJHtCq4dsykUQMaNUFiJcXUiTrjR6oCLWbofXK4ujrg3kJ1hdNCy6Fyz4GB31koQ4briPCMgordpUHLHeq6AEgJFHiNCWyiWRDnXyPsejcHTWA6HFpWHrBDkodUewTY484UuBELJCv8WCeXoocM8QHfhHNtPbJUyaGLHJqy7Kkf8ZDwtAuEG2Ago37w7dujotZLAXEqqd8pnZjLmZrS3KxuF5NYSY4yUhBSTvw2b3mLsE3Ue1XcF8SaQG3poeksv2rVNenuSm3N56K4x9sjxHCJ16ca4AnEprjNJhsd8upHmLgugUWFS4ukdQBAXC7EgPKHEP4sRvPDshnn6aHeuw1u92mABkZpjFbSoS9Z5me5nNi2wyXMT7DxZdFkSbuvKBQanym63yahXBEFUpXGyvHEpAsxY7935Y3S43C7HMcnZ9QA4Gef2FHEpH27fpNV42jEJCbtfqvGJY7PzhCK6ks5iktRLtRivhYo6unzqrhjU8JdfkJJtTb2m5e4yPfwho1m5ZYeBdytTQHzQRLZAsYFsdf9MCGAg8HiboJ4UFYGbLmZbAXUr3MnsyYJJjKVSLVce3w5ZbRrrYm32MYzQVsm1hU1XUSt6mekSJMRBRHKpPNspHZGCf7iZ99rgKzdVo11S9EmprATdVzXLVvQfo4YutEwvGa7Uzfexck3oGZ3kpDkTHJSQGGFkG594o7AhfpwkfnSswzzM6SVDc8eQZgU5VrM7zHaDVagbEu8nkc1rC1o8SM8uSEqcyYDCPTKKDEitAJcefgqiegKkh8Jf4vMsppNAY7au4bV2exE7ZQnoybG1fdGDMxmerGnbS1bAqeRPp6DYi7yzYkgTVrbfSFxWgS9a5FRd6KkzbRKBu382QToiMwX1EzWxc8RKfDZ1YTx7ZQMvFQJUhWPby5RaGPgcW5ojUx88aFRYAgRMqxFiA2W4cE3JkGazJeUY1LXVN3yKLS3unzhi6uG5JLvpYYzFQHbSaphUveDBFraeDiw2VBsMorjvf8kXqxtYfnpAG1wAu3wdMZJaevwbUwRaSTVJYCQVpUwzozNaMjJmBFnwU6DH2HYhMwXPKX4xDpgt78zMB3n15fLXtRbbMAeQaVRSDEyy6kqJBR9htgYHg6SPUWdwA9Q9sXQweH1CsTNRFdN7517tsem5cB2rAioZjePtmRyVBBa1FfeoakHBR2K4GqBKEZESFnbVKgDa5QUvDkyqD5Rr8NXRTviJ3a5wJo2pbojx4H98WUSXM28pwwSZycoVXuhwYADp1Rzm9hKSR7ux1huXZ7WP4ZD6aEabvDaMrbdT5EQoxxcxRKbZchHEAJLMg93BdFrmwZjABjYaAkFvqtRhhpvEm3KqSQbBx364YZABqGd5DzELg91aN4Dt1KXMLyqEWmbH4mpoS1G91XWtVS1u9ZWeY4RjisNrpDNUApnbezqJYanJAYCC2z3Dk7h5P9UycBqxM7iA2XeZ1M87NVRH7hnFsdHqpJKmhTD7BWUre7Q51hBh9a79CHg1bGixKBqgK6MSkdWcxzMSHWkTKmvoP4Vw6hZfMEes6XReUHCWdAceJuK7YmBXVUY98a1Z3PTThLanvPPghemfUo3L8XTBSPdk9S5fy9NxeW1mHLa3zCJRuFepWP4mceRF3ypGjeSAZCZ6TudGb3H7myCfptrEqDG7X9fgNR9Cotux7kr8FVEBsR4oFzvXpkNT7tZvDSjWY9Tuuz6uzzgfuwHrzB8mjRJeiCPPwzLX8UDobTCqNrEDv5anpCaFXPXA9C9upK4nFtS1rNMEjJ8sWaWsAfNLwsMS87mubX8NUYxU1CUtXBvaJfkxyPv7WZLuiEJapeVEkhnSZYFUrQ4X8TwFfMHpXXmdTpScVbCeKjiRWUdjfUM3e5qS7evQYDMNQxkXBZXohcKQqCKeWu4Qhp8wXmurV6gRUBTtFYuodY6yVJu8a8mcg5UywvqjNekUgGaFbhq1DFe5QVAPq9XNZ5eiVMFnVLzRvHFJbp5DNzWBcqngD2grzm2owTbRiA3rvchWMULVpVZ7xHdg8umu4ovFLpCYqkjm3n132Tc6uia1LSv71ov8NLVzb7nFcbFgLbf3htuaHkWqU1vs6V122HKF7Fq8M3cr6cT5XBHzHLwEChDmP1CNAcvLz7g8fhn7Gpx34Z5ZMVN4FbjSShQfFEEPQ3HxyKGh6DrwpM2hSisdexBvph7DuArLYFEFnkPKTqmY2se7vug3wLUuuuHqLdwqNDM9134Sd1i2WFeVwEaNe8mXYDK8vABVf6JCQuXu4VNGLF92StTZ9PBbTaRCYe4xyXb5DUttrCfN4oB2UanbRJjN8tC6qQD8Wcu4xy4bcfi3WARgBYfQ16CrtaTQKdmAcRdoABCq2JWjo8xU3awrsUWYaNFWGGcF2YFF4hgkfFJsAnBjN8pqR5LCRNr6M3Yxe2m9YYyMyz38CQz1dd1pcF3Q292sWnapXHYBpX84MxPSwpjM1Yb58JAxcJYNjez2dVCBe4fJCM3dzQyTDB8dTpzoRtoB19tw2zHxis7wmLYHkM1w7yscNYGpUcyzLSCq2yX7xPP4G6uSw7fHBotw8YSeQSrcvRb1bERj4WfceC6Ei44E8e5u9N2iZafS2RpjEM9sKJyn4tTVWQkMbfZ4YgmuBebsHvVAn4Z2XqwHsv5QWGnBgHXy9oZuUScRewD4b8gst4wnQMZJAfnw9FJyEeaZzWAaZKB1h3qYPWbyt1E8vjtBmXQB5HqbzmTDmnyEFYtdKha5buJVdaPh8cZUHYSHtM7L5Y2sRhGtRHszhzg2B8KqMbjSkxVkRjnVT6Am8F5hiDa8RrgMiR9kfMDWaa8QbrPuFuo15NV8jAde2n8dA9BomADMqJiZcWNjaT8RmZ2u9gSXcSzRShb1P2fHRPgtExUqTWvhKvQ6F3gxaJ7GeVp9MLc11yaEY8SW9FRUsDT7SKm7XSmr5i6fRuqXgQZFMHGikiQnpfPai19AfGXpAJJE4YJRCgsEA4rdcnVKL8uWqga3JNRiJgDj2WF6pKCb1iYa63gochEJZT2EBReZdiB4B6QQmVVSUGcYMeexp4TdQnAKD5Wx6Eukb981ezxxA3UYG8RXnWsFjKuHsMs914nQMtDCruBRTJoNL2bVYvLQf9a1H59waxGv16JSbbkJ8oX2FWyJ8XXR6f8w3AUeVBYRVjmexfcfqcBQn4wxqzGRm1z9tvDAGasZAaSbZcNS1Z1hZJeWpuenQHPHjMv5eiX6wJxawdLQxTFSiAktScThUgtQLgyD8jLos2NxChqcCzTUYyLLBzUiBGgGpaMb3DJcj4tnhV5WS8yxiccTWby9BbNwJhtkEZ9UYcYHr1rovdDp8gnU4HNhv1poBVtteNjAijPF35wzV2o88gjoqZtsbHmZzdZ6HGnjbbFqoL6hj1SSxzNzyjPVKNkVNLZpfHsN2rwPyUq8cGdqVEV1yjjJPtncEbJ8L6X728ZjHP73E6UKBrdtvzoPkNYor5MYNyvSkLuf2zZusxhF9BqvAg54pGNKMTNcxTeRNuD2MN4o6QsSSRqRfiUa2KSJsjKoEep4spNL89SEmmDmW2dP2Y5xPZC1uk2cXpdsW1tvmzVyxuBPTPKvoFWHgkapYRKq5jv6ZhcJvAkgu6DfwQTrbJWUQBXi5ZWhpNiPWaDUt5hkXHbYhuZ5yCf7c1JCz6fBU4f4YwPWeJcKUnjouPULoYNn1PfsbrS6BMnaDCbfePdE2tdEsbp7SAQ7hd4JQHxkYrdzUCQU2uTrq5VAUiKHzcvKLsQfQfEBUnte6R1RjEe9t7HKEgnHGuinEf7s9pqnm6Cb6vQdjwqGTzXutYAjSHj7AsySFqNpPX7aNzGGDrGjpC1v8uuE8mNkL1RaSVNt12oiKa7iaoJazyXoP1Z5W9rC7vvypM32KFYx6KbD1SZ3ZWi4CN5HTgv1PCVfpF3XRGinWdTx4CAUV7YLMKK1aiiLYLUniPJoc9sBsFRbxk9p1r1maLeUHxFT18kc9zEujnMFmPkDjZLhpM2bLrzzNVjsEpfr5VDBKVywyKPFya1NGnzeXWFePitHPCcjnH9vRXSVNA89WV4SutGXmnzCTFWsCt2iBoEsRoE7Pn12kPQfAn7Nuhc3mXHNQgLVH9qZ5MgXQXzrawZ7uksyCBPwr6h1GaiW6VwZUVLP6GckFetLvjyBfY884RTj5ViCPihieoqtqTPW74zVTRxKTcQukpbzaVtTcNcZuyKk7wg7TLgzquj1ZkyBJ4eomo9P9oz72w9829fREGKgVnLXBGKn8wmc5VRJuHDkB4jRK8xJejzxAWtQVovezVoHHMxyJT174NTZe6rwkjJ8mfi2To3j7VNx2YKExJV2SdmdiB1va12Tzgv6ct4CPkUvKRc8jKaBUfMadzvrLZ1Pyr6ZvK4bDmdAn1rocnKCchag1sLwD4hTJg26goG8CcFNdMvwUXw4B2MZpvWaQWHtGshi7MqA1EsWDpFkVqZxNEWaut2jCCxnoJfLhQa9VhGY5FB11o1Jed24HbkNNvjJNjByaJr6mhPqtpYn6t2WejGc4UrrXyPDr6j5wXuucud1SZctTjuXM9KQHJtqx4g6RuErv6dMktoWTB4dtf6qWkZ9CBUx32ggaC5dUKRSE7n3W7B1ZkbUbKiyJRopESyRCKfADqXW9LLo994YczwRUeYTZ5jmoh9f1DqN7KLZ7aXcvXCXSwdpwYAMMKdJKFWLnFx8j1rr8jLZgetB3gXkbBbuUYk3mek6KHugLiSGxbxahDVjTwko4V8wrSqbQsFist8ENhLzTacXfPMU4ycAP4kpyxw4NHziinrm1HSXf5UyZGN4rS6MtkGth5UfwhSP8wsnRzgRJoPxgjHqhWdXcMutnGxct9L2SMj7CzkGTTF1pLaDC4PYQ6KzarkcaMwXfZpH8VU391zLnm5CqGCGLToQ7yV42vuJ9ipyXpoQEcBP7ocfzvnu6K5h2e3To94gt7W92mcRPxDRKKHhwbfj2nxJLP7obtV2XcpVcGvJiD8NS66sgsUvaFk9DBsN7yrg54XySsTXDXmSQbS4RohtY8LTJXTC9bXrAcQEeF8BqtSPa15BSy5AwwUmkW3fHqBH6ybuumrJBufrFv5g6Khdo3vDnZnctCmX33o1qAEs2KZ32qupr16FPnw9t3SdHz2vMCcgof7Vx9mcbteWCSGm214HjRNtRAomqnLKvQNKep9iJBrVeLDgJFNUpSoMBCjdzrEaxyVPZbgNx3GUivvfq8HGx3vipzBJVzRFEMJrtFLora5uVV1ME7i79sQxDMr48Gtp4LF6BKr6PinLMAqTpCHCeJjJ8jQ38rzYisZkpZionQ5VrZcZs8c2Sse1hhiHkTGjvbKpHfRPXSTyJMBRWiYAxTZEAFmSQgBHuqVfYqdXFFk2a2nz6W2oHjsdjK3GFoquCyUxKmiEk5M4iXThMexu4yW9KH4EKLzqrGegsfkPdXEdZxAWWttK5D1uSEcdQZeMEDextM4ZwF5rASQabd3JfqChdumpHMKG7BWZkJoP4oiLN12hVgUBrfggPjNboWQc2HFBrnRLrSq36kHTdHJuNwMYMsFfu6zQD2tL8HRB6LAdnbsidPR34LmTSNBUWvzXfp8bRyeWEa4AmASHKsTZVUUqwxpYKcA8W64TYSFYiqf8mhRM5JVMZ5Ppw1je4V44ZvNnrTqgZ9amk6zxUCbbcyGipuNUc9EEyYKyBrLrQHt8hMQ1cwPKRjFuGjaH6PMPu2T28uNtkYBXFv1iQVJw9JUUrHMXwjygeG45eREtNVAfz1RmcZd9o6oQ4SXxsXQn2wjBQos3RRJi1XXc4d3CgtTqwgRrD1PXSrW2ttsMgLZw82dJLYQPcoikjWReGwz1PJX4YR9vsus2H9TsqcRhicEPzd1iL7V5bAA8frLKNMTyNqQodV5S8YZqC8bcvoRrZ3KWqCKsbdE8PaXu1YZpmpm8DxPmzZqwGq55spXvrhT5dNR3Bap8aiSHMVPNA3Tb8wzq16mT5inJjLo9zM4uv3ksmwb6teK8q2goB8jTMzx1gDwdMBTxUCvWPa6NihF1s4TRmmiwbrxqpMjoymxj5aC9pYh5oEdKFvGRXVvMF8t4T6KmCf26HZ8Mdp48UyQnU2hrdKpNJLWdvChTfqEBXQNdYeKGVwXN4nQjeQFvr9ucUFaJ5CnumxMR6CaosHwdgoQrcuECqiWf2X5BRtri9Z1WPFsmauhtBjcVtc2MsDAM8f2au2CN3aYkhW67TLpLYdv9hqcrVaJb1NiAS98TrjcC5j1FmGYghqRwmgwQmHuG5RKv3G2gsmiibr2z3L8UR4VcnApcA87RxyQ4gdKNgeheewwYuF6Jyqh8aZxsfJkakZMQPYtod3uT6KfFmCSvmmucwn82Fu26XDpJqXV95P8N2gGkUy5PV8v4ZescQZxjdJfmcZ5LigMihhFsa2aPiGf7aT1Nn7XXyJW2RcR7DhyBKUBVZrmCNbH7FxBVEnFNiaRiQRbo4ppat7o8h6izoxyxqTuaiMv9NJBxxAfSCywbKwdLEmuTGGhZE1THARK85gLdYT2abbPgf5iVJRHV3wysFBTYtq2YBMWQgJqDgdbGBfy835C9cAAwauXpP6BwUDmeUo2nnzjRstD8tw1EMiYmRK2BgJxaP6uhFNTSLzQvXMsP3KHQ7o4N621B6643DHDWgjUGvJsYshjE2Er9gi25QYk5fHZhno7jKRcGepLwEumsnWWUSydUPHpkkvBqXySobSDq9rfsX5cTsUHKFpAB47vQLymHrR1E9aduSyznrsP4e1Vt43RcMiFPwj8eXAHUZ9Co23qNxQApiXxv5FfjJwnMTtzGSFaM6bUBB9vKwX2HEETw7CywqMwxbxn5BnkvYfirUwrZBs4QpAMcqSNEirwv3CF8QsxCPnHRtd8Kf1CyxAxrwUMpCkCG7tH26VJMfQPLG5gM3jcpz5En4pssegCAV5Df82Wv3zRAGL9i1nk79dcNJkjEuNS4qSVEiBaumj9XCqTQZsKnHh1gaCGruHhNV7q5m2iD78hU1y1P86gbFSEPPoe9LG8BohhesvL8YVM6tN9ApLrf4Z841jVvPUCWwLXJ1wkbxB4t3ByBDUtvejus15VrmK5ojKTCmjydCSpDX3Syw5rPC2uQcTe4fhXHy4pzKT5PAzB8WmjjkjCWVhkx3jb7rYCdQxhwHYKLLi8VwV99oXR4FM32P1oo1tJEYXfqBoj8edtJpDVHkoH3w7cvpfR4Gz9cCuyy6TP2EvsPFxTxFxjJfrVX5bYugfkyCQt47s1HheMkizkKVaTs1JPRLwKvhFub3df1qV487YviMBkYzV8kV7dYs1c4384GmBBcAs9hcMyg3vMXQjoJk26xWrz","attributeCiphertexts":{"0":{"credentialSubject":{"SSN":["PhFZmJkuyt9TrHNrz9iSAgcK7qBhNTUzqHLA5iTZCHxzPZp4nxhTcwNbTKjTQhekK4zhXcHwL2J6dq87hTuqtVj1TydW3GSYSmCTvRDoUB4R2fNed2MtdZdLNNbwroyWgdnwmqNSAGtnt993pr2pZBFYGcZCxMp46FkrimXQZ8Sca3TTDWNPKui3p3gkvasZAE8vw3J7njuJp1sYo1utP5jYFc6mFq544iwFrpJQD7gmxZTLjUAsAEnFZc9wRXSVmVcbSJtzE2hRoWR4CCMnAyu44gs6NfLmRKFmzasjk7d3vZncSZimUHWWdFnGFrFEHWxZeh3PzCbY6knUTCasAmqrp1kBJuadTkKzzKSpCVazcRYH353yRasSPi1x94Vj3PWEFXfxpjS83SUjPEQnFLMHFt6M4XShjZWL4r9MaeidVDxvTSPRaBfrZnz6wwZBULbgH5G62LYrX8oZvqCP2meXiXkCPJyM8bBcUERowNxoDjFiESyh4hwNoJtCqYTnLEyZVvuvzbjYp8teFAKwAtdUEss1FY2BgSt1WeamTav98aCNao3pi3JCmeoEwdMErkJtGhDvNpub488RiU5YoMC85e4xvxEePyhnZgzUMh15PaaxtHQurFLJJsVxU9WCLJqBoL26K6T2zCBZLvpwQhHBuhFLadiCv9WfN4HGsYySvtqp5JA5jo49nNdSJBVwmNQyhbveCuFfee5mUgyCqzNHNdvFRK8bgPEFLMqAboAVq7H4SoLJX52cQdFcKF7gNmac9UAoNrnoyDey5hbz1z9JhKeNi3jQS6PmBHWy5w1pGukDc29FujYGj5WB9Rie8YzePZXasersnf6HCV8omGc2az66425ZjmMtu8HyzyX2QaC8TtJZwNLnLKpMy2FkvoB1ZJBM8p7gpVad3927dmHR6xpv7oHzN3FMCqazoVkPBae5Lb14PknbRgB8YfJGpE15yEJCJmTmHwgp45qWdyfF8Ng1z3Ti8D6LKVLdZT2JbRPRC9xxJnj1i1FZdkq8gQQqZGinNGmrj65nCbSaDVuaW7HC87vVr8vsUuVkWME66LCS3kxkeorygAq8VMPxER7f38wuZAoHN7Jq7jfMRZqhABaiMgVPzVtQPJwa2cfymqgRZX8dFzizRV9tqLJ5cVjj4AA2JEr4oHLdxsuUgokm4khBMFKtmcJxG51"]}},"1":{"credentialSubject":{"sensitive":{"userId":["Q5THWgD9abH56FaRSK1wNTnz8AMAQbrehppLzfatkLb8U5GnrxTND585p88svG7VVoPonkWWth8MajWL3HGxbYYAMHCthctbbHzbgSiAAhfgtLeRtPpZF4naZGwxb8CdhGfg39EvfcVn5NhyipxEcjbsUiNqp1By2QGzKeKptKZtkeXgk8RoScotjYF89GMWfpsddSrLoSvpPrgqw9FsQT8KxZYpmF33mcpgfvVET8qHB2Be76TYJB7pFC9n4N36K53rCcQ76TagUVGUzbSKKp7oTAehnvWPBZvQUUbeRjiyuL25RQiv1q1BGJYCd2VQZEgr1NgvwHqhACGqQ36czPScMTxsHHow7kgUF6J1uhA2tAY2kuXzvAhEiH74tC5Fr1SoknwyUCBX7PDEtzf2k7SK7FvSknj3mPiim6EZZRcZqyj6fHRErJJ59eBL3REvbvuS3XMyVFSZKsA5nZu2zsx1kZS9cQayeuQSPM6tDJgbCnZxQHjZEssysQvjgf2ZsDkvzRdprFXcABCyXS3D4MYZpCYDWCs7fm47dQZZZxK3ysUmmLwqQS4rdFb4ndBSQWmSNm9NAdD2Hn6Ua8diPFMkJVMzCNZ6pGz4mtcB45q1x7KLtBpZijoe71gRXL7Z6v2SaNazHKM9NBmsaXUj39EN8GDZWzDiSaK1uPfSWZaG9u3XzoLeDN1b9zJpKX6cNJtQJY2CfgEzpiGsutSekSXn6f3jGF6zR27d6zcyceNdbVt9xci1rnvh8NLeFgC8hX84hweXqJmkPuJV7aZLjEKrQh1vnJDaouAPCLwY95xkgdwffD32cPGyHy6XMk72Af4MHCf18JL7NByhYa4fSKrFU6Q7rmKfdyUnjm6PDzezXjYEfX2M3Pbj7JM842axT2rPinvfW3ZbqoNUK1VhWNGK6dWYJKfoB8sQEtuqdbMB9cAedo64NejBqFb3PmdaWn3KusWMiJdDHk3BPVL4dsA5xg9NQSZr1wsK4sDHDxhKCRsnwDx8m8PM4gS5rn1z3SDR5rSUK1YxuwZQpudde9HXLXPRRdKuaEPSXe2mdeLQr9ru4PU5mKKVbsYoaPVRRr7CisBh61iMLYpT5JXEoVoxHBWnRGwvPh9YKGExsN8Y543FsafEWmsVKQByHp7oK8V1zxGPU1msFRNMA8yWYWWV5LdtizDQsPp4Xpp"]}}}}} \ No newline at end of file diff --git a/tests/anonymous-credentials/serialized-objects/bbs+-presentation-0.10.0.json b/tests/anonymous-credentials/serialized-objects/bbs+-presentation-0.10.0.json index 9adb25da..433ef045 100644 --- a/tests/anonymous-credentials/serialized-objects/bbs+-presentation-0.10.0.json +++ b/tests/anonymous-credentials/serialized-objects/bbs+-presentation-0.10.0.json @@ -1 +1 @@ -{"version":"0.10.0","nonce":null,"spec":{"credentials":[{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"},\"email\":{\"type\":\"string\"},\"fname\":{\"type\":\"string\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"lname\":{\"type\":\"string\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"secret\":{\"type\":\"string\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lname":"Smith"}},"bounds":{"credentialSubject":{"timeOfBirth":[{"min":1662010838000,"max":1662010856123,"paramId":"random","protocol":"LegoGroth16"}],"BMI":[{"min":10,"max":40,"paramId":"random","protocol":"LegoGroth16"}],"score":[{"min":-40.5,"max":60.7,"paramId":"random","protocol":"LegoGroth16"}]}},"verifiableEncryptions":{"credentialSubject":{"SSN":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}},"sigType":"Bls12381BBS+SignatureDock2022"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"isbool\":{\"type\":\"boolean\"},\"lname\":{\"type\":\"string\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"},\"physical\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"secret\":{\"type\":\"string\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"}},\"type\":\"object\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","location":{"country":"USA"}}},"verifiableEncryptions":{"credentialSubject":{"sensitive":{"userId":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}}},"sigType":"Bls12381BBS+SignatureDock2022"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialStatus\":{\"properties\":{\"id\":{\"type\":\"string\"},\"revocationCheck\":{\"type\":\"string\"},\"revocationId\":{\"type\":\"string\"},\"type\":{\"type\":\"string\"}},\"type\":\"object\"},\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"lessSensitive\":{\"properties\":{\"department\":{\"properties\":{\"location\":{\"properties\":{\"geo\":{\"properties\":{\"lat\":{\"minimum\":-90,\"multipleOf\":0.001,\"type\":\"number\"},\"long\":{\"minimum\":-180,\"multipleOf\":0.001,\"type\":\"number\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"lname\":{\"type\":\"string\"},\"rank\":{\"minimum\":0,\"type\":\"integer\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"phone\":{\"type\":\"string\"},\"very\":{\"properties\":{\"secret\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lessSensitive":{"location":{"country":"USA"},"department":{"location":{"name":"Somewhere"}}}}},"status":{"id":"dock:accumulator:accumId123","type":"DockVBAccumulator2022","revocationCheck":"membership","accumulated":"5iYSR7j6eCT2nvmKMGE3f88CQ73crNhcesj1Nq6JwkqbvCzuyR9qNYWLpvyJU1h27d","extra":{"blockNo":2010334}},"bounds":{"credentialSubject":{"lessSensitive":{"department":{"location":{"geo":{"lat":[{"min":-30,"max":50,"paramId":"random","protocol":"LegoGroth16"}],"long":[{"min":-10,"max":85,"paramId":"random","protocol":"LegoGroth16"}]}}}}}},"sigType":"Bls12381BBS+SignatureDock2022"}],"attributeEqualities":[[[0,"credentialSubject.SSN"],[1,"credentialSubject.sensitive.SSN"],[2,"credentialSubject.sensitive.SSN"]],[[0,"credentialSubject.timeOfBirth"],[1,"credentialSubject.timeOfBirth"]],[[0,"credentialSubject.BMI"],[1,"credentialSubject.physical.BMI"]],[[0,"credentialSubject.score"],[1,"credentialSubject.score"]],[[0,"credentialSubject.userId"],[1,"credentialSubject.sensitive.userId"]]],"boundedPseudonyms":{},"unboundedPseudonyms":{}},"proof":"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","attributeCiphertexts":{"0":{"credentialSubject":{"SSN":["NswuQv8MCL9q3MnqAUTkjfDSXrQuzznQrSaybpqibRy82GeSk11E2kLH9ryKYk9pDqP18AQ1ek5PMUr6bpdW9iAaoZatVQJuwuDWJQ7U2tjsEpuK56FNcy8DU2dp7BztLLBvWHtk7ZzKV5xAwANa6SGiG8FAC1WwBaNTfheW3LnMeDVWuFNoxtW5qXNrmjdJHxP7p1AUZeCeG2TJsxUfVpCx2GXiYqyZFqRVyZNnSGNWuUTPAekeyWzfbqKHBeBHS5gE4EnCRbD1Lfegwnh9VYFanjoYAR5D7KE1LWWHtwYrXaZnftFxRKf3U2X9XVp5NKYkrXVrUzz7sfDvb4gYgvXohp5mayGowDa4aKw7QdF3ZsKfa2phbbHs9w86pdLzwMNs52yFBQczpWfe21FDZmgDoVVvsihpazUx97Zg19QMAmS5bkW5wasz69CouBgFUiBtkFRs9k6Jvb3Gx23eWc3Wa32mBqpWSZJiscyZZtcUuRm2N2nAnFqYd1Yr46YVa5pqCYYRPvnNcmirfaffRhC9LSL4XBbSNa7z19Rt5sqYa6pBjXm5a29FtW1QCmT19U2GQaj1DrpMXZ4dxc85pc3g4joByhUrDZy9aRKuSsbtcupUbpz6ZVLQagkmh4H2AZohhnWWKdP356scaPEuvKZasHsgXzHHAHbg6m5xaaghzskFwGzppqozyqi7RVowXmzFAg7kqxbUYJG39CrWcVdh6TcD8Kn51YSLy5Af3i2JrJB3PNdX8KPjXbebCbrewVsQvibTd3seriebpZDgHUpGj9BgDNzGxFtqVpe72t37rCrHzaePtezAn4bLrxgjYAcCRDqc5Vs9Ffj7K7QpXW8oLtif8zoy27DBERW857Wgsu58kSSFAfib8hLaPDFNQ4SD7F6N4XXQhAKkv9cusZ28QKtnQMDUEWrhd3cKgBh3BSsyDtNac4M4Vp9Pyk71iZ96WAK7j64QGKmWHTy7BSPoF49sU6XdaJG68hbcVE915e6cFWB9W16Xd3wRVcfAFZ9f93u47irgSV4eZLpGNtq7bvPTYitDeCFW6C6gdPtK17xH9hZFgdHcLYurpYzcn8bDCBfg4uN7jPQSfj2T4yKNSF5inYuR9oe5FiXJPJ5Qd2xEQvj8REwvt3R2Xveyjqt5PsGvCgmXHAhhf8Evt31bxgNpza2feFWbWKu"]}},"1":{"credentialSubject":{"sensitive":{"userId":["JTSv7ovABJjmEg5W1FjXyDeS8b8p3RXRwMD1M19Eagr4izZS5XSXP6BqWc2osQSuFaskUAcTPcGBqcQxoDYHF2hsdghks6CzdrBSFftbXrD8WJyF7FdQUsNLHKvC1b9aR8icxqQwE9QkRFxrf8Gvx6xtDcmCmczpF1jV3KqGqa2BoqBrDCJ4CFyKF2YqdUb3za9JBrrwTZpDLDi5HuJaDWNGqV4iGRZf3RiQxZ2aFGMy1corFHMpA5SxYW6jstVLCJhKpYJoomL9JUwKgtcYxio3HLYCQvGV5oyuGz3TMUrykoqEiP6u8Jp4tju3fCbLvaqLKYU2Jse5bm5fscQkD9uzCFyV3vk55jBnGJNKn2s41cfPdvgMKfRzrPyVeofj4wEtm6NXJHQ8uY8sSECjpduo4vwAQ6GkoQ9po8N2sWVUmVDYP4NGqtGB8xjTCd1QMtAY5YeP7pTB9zEVxKP9iVE55UktkGUXrQSxnHKXbV8mMWgrRhp16LeiqHq3Z5mqEN9fvA8jRcP5YwuHT11UZpR2SfRY1ocwvSnVDo1M6GV1BGA7UAS3TgwdwsL9Ujpie94mmoVMXgafUjq9UA6LGhfruCEZAR7PiZoTn3KmzyjgTUxFaPn4o36yjgSipfxbU41968pbiBypbLufrDeDxs8UbCEifXXdQCrWBFFDSxED65VtJVaiE1HYFdFWfUko1PTGSGFR44XFyuC9U1yeG2ZbY3NyjocpghH2Vskxb2qgf7MVYCWqgELGZbh78UmDr5qV32q6RRjVAP6urW9KvWm9ZVyW2RGeQbDX3YFehCXiD4pboeWuqaUVDLi1KKkD4cexEqrsQ4pw5G3ZBwXK4YpprSy6Uv3oT3SVqDSYGRmH2uRpagk8jKNuZjFR9rDHVq31cx7peikdCRpVsDQZrxbNrFC62i2fSBJdN6xuBoXFBiJb8bKtyF8yqCHcYpSh718yfHHP9bwU6dcXr3FYub89YVDyJqAWFznT3QNdz2fVwyLhjRrHBp4CpdsBBPdkKPyoYnvxBRDW1ysRyugFMj7XntcBBeMxRkao1fb6sUcfY81e1b3VTQbErFrqphzjgZRTgacenwvVGRZK7BVxwkbUm2HRpKaWnCeEJxpVQ6rawACiHjAs5nqZCQkY7UE6vDKjsBkEGP5nQMWijJwHEfpTNX5924LuNo9rG2d"]}}}}} \ No newline at end of file +{"version":"0.10.0","nonce":null,"spec":{"credentials":[{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"},\"email\":{\"type\":\"string\"},\"fname\":{\"type\":\"string\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"lname\":{\"type\":\"string\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"secret\":{\"type\":\"string\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lname":"Smith"}},"bounds":{"credentialSubject":{"timeOfBirth":[{"min":1662010838000,"max":1662010856123,"paramId":"random","protocol":"LegoGroth16"}],"BMI":[{"min":10,"max":40,"paramId":"random","protocol":"LegoGroth16"}],"score":[{"min":-40.5,"max":60.7,"paramId":"random","protocol":"LegoGroth16"}]}},"verifiableEncryptions":{"credentialSubject":{"SSN":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}},"sigType":"Bls12381BBS+SignatureDock2022"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"isbool\":{\"type\":\"boolean\"},\"lname\":{\"type\":\"string\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"},\"physical\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"secret\":{\"type\":\"string\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"}},\"type\":\"object\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","location":{"country":"USA"}}},"verifiableEncryptions":{"credentialSubject":{"sensitive":{"userId":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}}},"sigType":"Bls12381BBS+SignatureDock2022"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialStatus\":{\"properties\":{\"id\":{\"type\":\"string\"},\"revocationCheck\":{\"type\":\"string\"},\"revocationId\":{\"type\":\"string\"},\"type\":{\"type\":\"string\"}},\"type\":\"object\"},\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"lessSensitive\":{\"properties\":{\"department\":{\"properties\":{\"location\":{\"properties\":{\"geo\":{\"properties\":{\"lat\":{\"minimum\":-90,\"multipleOf\":0.001,\"type\":\"number\"},\"long\":{\"minimum\":-180,\"multipleOf\":0.001,\"type\":\"number\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"lname\":{\"type\":\"string\"},\"rank\":{\"minimum\":0,\"type\":\"integer\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"phone\":{\"type\":\"string\"},\"very\":{\"properties\":{\"secret\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lessSensitive":{"location":{"country":"USA"},"department":{"location":{"name":"Somewhere"}}}}},"status":{"id":"dock:accumulator:accumId123","type":"DockVBAccumulator2022","revocationCheck":"membership","accumulated":"5iYSR7j6eCT2nvmKMGE3f88CQ73crNhcesj1Nq6JwkqbvCzuyR9qNYWLpvyJU1h27d","extra":{"blockNo":2010334}},"bounds":{"credentialSubject":{"lessSensitive":{"department":{"location":{"geo":{"lat":[{"min":-30,"max":50,"paramId":"random","protocol":"LegoGroth16"}],"long":[{"min":-10,"max":85,"paramId":"random","protocol":"LegoGroth16"}]}}}}}},"sigType":"Bls12381BBS+SignatureDock2022"}],"attributeEqualities":[[[0,"credentialSubject.SSN"],[1,"credentialSubject.sensitive.SSN"],[2,"credentialSubject.sensitive.SSN"]],[[0,"credentialSubject.timeOfBirth"],[1,"credentialSubject.timeOfBirth"]],[[0,"credentialSubject.BMI"],[1,"credentialSubject.physical.BMI"]],[[0,"credentialSubject.score"],[1,"credentialSubject.score"]],[[0,"credentialSubject.userId"],[1,"credentialSubject.sensitive.userId"]]],"boundedPseudonyms":{},"unboundedPseudonyms":{}},"proof":"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","attributeCiphertexts":{"0":{"credentialSubject":{"SSN":["KrAeb3k4rF1WYL4DRX2WiAbmzyUYsRMx1aSXmBBMNxjsv6eaZjwdGSjXLv758NwmvZn5XfkTEXHCF7X1RM3s8JRD7xQc57QpVGMGXNcCgyzypmHB8k5ShXbSCFCpLyMgq699eogbKUjMZM39MWGrHATMpskLtY1UyWkrun68iYsivpRaxcjaJrAFbd533uMhBR8jcRBmbCsRcofJ4FD5YzWQWyLGhzMUCBPkJgHQ8meUDeaAHqfX9b3Vo9vaCcVnU2ijkHYQ2Ezcm6iVxUisbLHF4KRdxwjop54oCGUN6Lvc7URopU41eW4Vs8UFQQcoUUhMQopVDe73aA5JyATwiFU9rVwZKctoJNnmCvD7U3yJCF9MgZfXfyFfsczhJiRYX1cgMqE8XEE3QwJx62Zpb3ZwqxdcPLE1XhjdY5EBaP4duZ5i4nquPf1PLGCWFQKHE2vnBSvyBhZ5bUZxfPZp35dGN7k9jiuSDtksPLRNhYNPtppqoLqdHVmWWXr4RnznKg6CAojmrCUG7Xk8aqpbEaPkfrBHL4y8tiTTzz2DEBmyTNvyk6EiRmy9DqakgUQHQxDgDfxJ7xbnWNeXFtEDzJN99fAA2pqSCNqsbNmbviRRocHu8dGVTKgUhYr7zzFBq9id11ee9uMzaQeDZ6RDNNzjbuDKzJtNqTcMVGDbRQPDYdB4LHMQ5QqhK4XSoGKbcePenSyBXBkx3Z5rjJNMdy4irHoqM9VKzrFG5ib9qawUKLenQ9XjDE1aiXSxh7NHJVr2znt5wYFs8xV5XAyC1vMLG9nqh7yF1sGn981U3Veir4w8jerqipejsLQ3EnL1Tk3dJjhsBnRhRM6huhSXqV29xQab8XFyoTVo7hk92ZbcKKnSgGew9s1UZHeCqZVb8FEN9fswMgLzVhdX4tALKEAAPjeZoC1jAKsnU188JEHJ1fD8Jfs5Joe93kpcW5MpWFsVFA2fsabDABVtskb1nZFbt2tSWtWYbffeQ9bDcm13paMGE34nQtjfkPU3Es67R8USZZVU9Yh2akYrjdxsdiSMPrbMNUib7syz8AXppVveY8RC5XEjyqioZr4JQDLAALC7JXsHqpDhi5vuCTyhDWJEN6WzG1sTDzDsLu1KNrqmkBNo1FK7wf5N9PPsJHKEfHQJSvRmJ3fcrCULuBFg7chSymip2nHScuLnQfD"]}},"1":{"credentialSubject":{"sensitive":{"userId":["K9E7R9hBi9MdVtTDY9qVFsLeSBJQGEikibq93se1VZREkwrZxid3ERaEHBXhhjaVq8Lbmx3APrDym5ZNBPypSdLCXET49HgcigMpya1QL43LhYaE8F2cG3H5SAwCiZrNzoTvNCfM9neJAhrnZSs6A2KCqQsWAgsepKFCJhvE4tzrnU2ZPek5DxtqCRCkH7h1ES9fzBK7VAHQD2ac8TPK7MGxsjBWctUDtHhbT9rHDFUZ5cokh5jELs5UE6uiLmJLNtn7LsCBQeEG4ejdy3JtbKjaPLUn83hD9pqrbHWSEZUZhjsDHRKxNdjTHrrqQVG2kHxgMb5bNWDz4ryBcXcd4qKYn5TqgMwuZRYtfjgjXCz3fTq3QYyHKdTydALe2PZ3hWDg2A1BjCsydLHTNYC2unPLMah7Q89ygHrBxJtd3ShGyAp9MF35U29Ebk7xcadsEkh88tQxxxLtajq78cdwCDZWYkVueAxpe2zoypUK64QGz3DRULtvwqdndELyqk1LWiJUWyiagu6pHUv1CvHZADzgrzCXFf4ZY72ND3yX9MyERvK9AyLG7BB4UnTktvHZYg5dkdYngAM3i7VBm7L6WhDR1B2RTTVBFLPnAqQkKBZKuSwKhXRpDvLvAyqxtYPd45BFPEiqrtHDKqAjjkfdoGsE3jxVPEn9nwYPijvzt392rF1D7ibwg9dKPjpdNMBBDBgtuefY1hGFqkn6tBSxu9didi9mU8LXE5WimXSxev67uPCiLFiuYcMkq61Bk5Yhb3r9PvgAvA2jrhPo6RdMjMmCs56zDvrBjnxgEEkwE6kxeW2zuaaHtpfiD9kcE9Y3yFUxNtnXPchUvqjkbUD1oheisvrN1qCnFUTkDKmXZ3uDz2VUzzU9pisKvfwYZnskrcPkxEbEd33LrCosLK8KJRPS2BeH3V7NTLtGoZvzvrhoStQuPTNSBASeNSSKLTcMZWkGZaUWcgQ1uXitFmiA3FrQpo9kCbTKKQhs3NpzDLQmq1AnZguy5Q6dFgwxRSoJG8FUcLWxH3vQ3ZdKE9RMyvfrdA8zwWvjejkF4TYXqwdzNDyXyb2ip6cnVyecKZ33ov6t7u7WcrKfjFMALkQr8XJmgFLd3QUvGT36L4B5FggXpWh7pYCVwNtP6WqD5ocbWn8f4XnK2Kb4EMfxMcxAXSgjKBFgw7KMWLUTM2k"]}}}}} \ No newline at end of file diff --git a/tests/anonymous-credentials/serialized-objects/bbs-presentation-0.10.0.json b/tests/anonymous-credentials/serialized-objects/bbs-presentation-0.10.0.json index 44b65d51..a18608b2 100644 --- a/tests/anonymous-credentials/serialized-objects/bbs-presentation-0.10.0.json +++ b/tests/anonymous-credentials/serialized-objects/bbs-presentation-0.10.0.json @@ -1 +1 @@ -{"version":"0.10.0","nonce":null,"spec":{"credentials":[{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"},\"email\":{\"type\":\"string\"},\"fname\":{\"type\":\"string\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"lname\":{\"type\":\"string\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"secret\":{\"type\":\"string\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lname":"Smith"}},"bounds":{"credentialSubject":{"timeOfBirth":[{"min":1662010838000,"max":1662010856123,"paramId":"random","protocol":"LegoGroth16"}],"BMI":[{"min":10,"max":40,"paramId":"random","protocol":"LegoGroth16"}],"score":[{"min":-40.5,"max":60.7,"paramId":"random","protocol":"LegoGroth16"}]}},"verifiableEncryptions":{"credentialSubject":{"SSN":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}},"sigType":"Bls12381BBSSignatureDock2023"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"isbool\":{\"type\":\"boolean\"},\"lname\":{\"type\":\"string\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"},\"physical\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"secret\":{\"type\":\"string\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"}},\"type\":\"object\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","location":{"country":"USA"}}},"verifiableEncryptions":{"credentialSubject":{"sensitive":{"userId":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}}},"sigType":"Bls12381BBSSignatureDock2023"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialStatus\":{\"properties\":{\"id\":{\"type\":\"string\"},\"revocationCheck\":{\"type\":\"string\"},\"revocationId\":{\"type\":\"string\"},\"type\":{\"type\":\"string\"}},\"type\":\"object\"},\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"lessSensitive\":{\"properties\":{\"department\":{\"properties\":{\"location\":{\"properties\":{\"geo\":{\"properties\":{\"lat\":{\"minimum\":-90,\"multipleOf\":0.001,\"type\":\"number\"},\"long\":{\"minimum\":-180,\"multipleOf\":0.001,\"type\":\"number\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"lname\":{\"type\":\"string\"},\"rank\":{\"minimum\":0,\"type\":\"integer\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"phone\":{\"type\":\"string\"},\"very\":{\"properties\":{\"secret\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lessSensitive":{"location":{"country":"USA"},"department":{"location":{"name":"Somewhere"}}}}},"status":{"id":"dock:accumulator:accumId123","type":"DockVBAccumulator2022","revocationCheck":"membership","accumulated":"5iYSR7j6eCT2nvmKMGE3f88CQ73crNhcesj1Nq6JwkqbvCzuyR9qNYWLpvyJU1h27d","extra":{"blockNo":2010334}},"bounds":{"credentialSubject":{"lessSensitive":{"department":{"location":{"geo":{"lat":[{"min":-30,"max":50,"paramId":"random","protocol":"LegoGroth16"}],"long":[{"min":-10,"max":85,"paramId":"random","protocol":"LegoGroth16"}]}}}}}},"sigType":"Bls12381BBSSignatureDock2023"}],"attributeEqualities":[[[0,"credentialSubject.SSN"],[1,"credentialSubject.sensitive.SSN"],[2,"credentialSubject.sensitive.SSN"]],[[0,"credentialSubject.timeOfBirth"],[1,"credentialSubject.timeOfBirth"]],[[0,"credentialSubject.BMI"],[1,"credentialSubject.physical.BMI"]],[[0,"credentialSubject.score"],[1,"credentialSubject.score"]],[[0,"credentialSubject.userId"],[1,"credentialSubject.sensitive.userId"]]],"boundedPseudonyms":{},"unboundedPseudonyms":{}},"proof":"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","attributeCiphertexts":{"0":{"credentialSubject":{"SSN":["NcEPecDy2YTkJZ89zhQiHcokxFM8Cj54i8ZvMSezPxESb3hd1N6seNzwyMMpBwDYSzgyrdWcPaFpNddDGJj27UkGMsK33yGpw96obB8g47mFsxNJvJ6aKCQWdT8GK8Kpbkb1VN3XbwtF7VMXCQB3wx6corFvR7afVWjdKRf3jNwkKyDH2oCCesXd8gMMVXKDZkgQH3npSLrprNfUaAuA8x2SL3KMXwfydBRGSuztMDrdrRMU7CJyzvopf7yPpzincL19J8FzcJpuxFv5T7uqfF5qvqZZzUtQ6ommJQ6ydfmG92nam5q9m2v3bRbrPpq4xp4dVLjN5RoUF53btzGwRBCnrPzKbhsKpJajqSMcH2mYH6kWZz6VKjbfeyTKqMDzyzrktegMzHXBHvni7cRTa8guQhzWyqcs7dmxrExTYUdZyM7geGpp1nwvMZuB8X9JbXooUvSubAY2BEPt5nSCvRSzfixpaDZdgWAkikd2XcwLPzbqMKuVpfZuW3m334QC347cxNgBtUSQK2YZuBEXvp9D2mbLD6sey3LGAjChbgKyWP5iBd7KH3rZoZ3eCG8cSEnySrn28JqhTFEbTu5Xnoim8foFSxYEAVAn6dVDS3ws3FnUmK2BfDUejHFt9JHK7Rnwjc9nni7zHc2WATK5J7ZLvBND4tLndkrHC4QxG3ueh1PZUcZ7bAGGjf3JY28Pe7oAxaSo259A4GBvUr7gTzgywtifDXzc9bN6jK2PjkK2m8gxfoXLvt84cubhBiigxT4WXnt78y7433aoGQf7gdQyJzPwDdgrfKdwpsco9Lv2VDmQ8rtn5GDW5YcuMEBeCdPUfNmyEPqERxjN1nW1WZknLWG2goVviKXrJAnDWtu7HA5xGJEzVQ6L2WGWT2NnK2HMY53NHCF7a9pdATQ9aJTxBtfavePCxbeEXRJmVdUCukuqitxNeW4otEdi12Y2szHCqmTtowXMXv9fnSuz9iNipPCsQGBQng3oN9CpqD7N2UKwxeDmJdwvWJ8jnPx7ios2JnGSUxoFqYdy2ahN8UYLEQPuwQ7mPDhK2LqbkyTNsQgHg8cYwM4CRgiWwW5vbLVSYYLwKTwNM5DGZ9eCWLTHmDhEjzCMceZVQyTPGYhDLkVakqzxCaFWm31J3ETYVsZk7aEeSnLM9NS14kFhyyHpGtiqGkBNkVsMDfN"]}},"1":{"credentialSubject":{"sensitive":{"userId":["Mn27Env7y1bwh3gdMKGZp5pCZfC4PpsGfZj2yyMRsVWZFyWFWWvzXHj3GEd23yeZoGJigGbpB9G8HbBfE8AcunFz9CX6Nq6geRMVEQRo4gHs1JpJ4j2e8Um2jBZeLCMbDE9UkikNhAK8j36siDngkijLdJEcMfcP3T7RgEc7qaFbUYueA4BFHaUJ2pMo6RNijXomB5qY9Nnp94KEq2h86T3img2rR3FEqKftuvmtqZPu5CNyaYTqDxwj3KTRqiGaXtfDvvcUZpBF5mejFzp8aL2V61TFEjQ8fDgJ9h8UMmvaxsqj7J2Agh8fZW7kEMAB62FhBPuUXbnx87a7tCzxkvc811CQGiUuZUQfS2foLPjCeVqRxfNbKdKdny8yLXjmjZ63FBzhnopDPA764xVageRk4Tmu9LjEhhdKeBQ5SL4Do67zXvby9xuL47GxwuJxFGBnchqX4Faa82S7rHB6iRoUfPogxogs1UjLaPLoYbsUgiuJTA7jRqDYmR1Bksc8Beyj9hwQru6ZkgEzpCWRjVSxD9nyDBQnqZUHhaAJXPo9hftzz7tGJyzCNErwm8ciRCAwQ3Vdo36kywuapwxhy4nGet2b42UuM1CSxvY6CTmHEnYE3AVHq1UDVB29aALP6zXYHCkbXcEKzyoq1rNZS2bxVK4ShXn7qrZXPs7kV28NAWcMMjs35G8SeCXSHxxgfpNkEKWtZGaUc7aD7MnE1YdApmsWbCAiMY9KANx7TmWpd7HKy2TuvVh4pQdHftzvZusirgYdDJnCpyQWoXfRBA4CP2ThTicZ7o9BAc3MtnYzNvSARMnwphZAjdBty8oAH8SiTyQrPDTR3JRMWQGAKjrXFULxRna3CSdRFbsEUweqUkpUMUna9cjifSQCeMxpaQLavJiB7h6cKCiaRcEMk3AY2Q1aPD2Rg2V1ctjpNCzAqMJg3cxSfcD1XUeKveWuEBkHcNmfzoBDkkESMKEDdCDTtzemsuVMu8aWoMVadvC8cwPrrLmR1U6zhrhWhFNFohtBj1LdVPyvujRcmJjs11AwjwNnXe8hpzCHp8VyYwBcQaqVFsgFwWdV14hHLQA2zHcGQKP6MJj8mjpwBSKjhkRQyJurx3knDkDGLAnuxLzZjfo8Paeqfypx1Y8Zj6okwgNyq1zAQbEPsR2G62Zoa4QPmYdDqVyURsbBrZ8"]}}}}} \ No newline at end of file +{"version":"0.10.0","nonce":null,"spec":{"credentials":[{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"},\"email\":{\"type\":\"string\"},\"fname\":{\"type\":\"string\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"lname\":{\"type\":\"string\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"secret\":{\"type\":\"string\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lname":"Smith"}},"bounds":{"credentialSubject":{"timeOfBirth":[{"min":1662010838000,"max":1662010856123,"paramId":"random","protocol":"LegoGroth16"}],"BMI":[{"min":10,"max":40,"paramId":"random","protocol":"LegoGroth16"}],"score":[{"min":-40.5,"max":60.7,"paramId":"random","protocol":"LegoGroth16"}]}},"verifiableEncryptions":{"credentialSubject":{"SSN":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}},"sigType":"Bls12381BBSSignatureDock2023"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"isbool\":{\"type\":\"boolean\"},\"lname\":{\"type\":\"string\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"},\"physical\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"secret\":{\"type\":\"string\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"}},\"type\":\"object\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","location":{"country":"USA"}}},"verifiableEncryptions":{"credentialSubject":{"sensitive":{"userId":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}}},"sigType":"Bls12381BBSSignatureDock2023"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialStatus\":{\"properties\":{\"id\":{\"type\":\"string\"},\"revocationCheck\":{\"type\":\"string\"},\"revocationId\":{\"type\":\"string\"},\"type\":{\"type\":\"string\"}},\"type\":\"object\"},\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"lessSensitive\":{\"properties\":{\"department\":{\"properties\":{\"location\":{\"properties\":{\"geo\":{\"properties\":{\"lat\":{\"minimum\":-90,\"multipleOf\":0.001,\"type\":\"number\"},\"long\":{\"minimum\":-180,\"multipleOf\":0.001,\"type\":\"number\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"lname\":{\"type\":\"string\"},\"rank\":{\"minimum\":0,\"type\":\"integer\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"phone\":{\"type\":\"string\"},\"very\":{\"properties\":{\"secret\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lessSensitive":{"location":{"country":"USA"},"department":{"location":{"name":"Somewhere"}}}}},"status":{"id":"dock:accumulator:accumId123","type":"DockVBAccumulator2022","revocationCheck":"membership","accumulated":"5iYSR7j6eCT2nvmKMGE3f88CQ73crNhcesj1Nq6JwkqbvCzuyR9qNYWLpvyJU1h27d","extra":{"blockNo":2010334}},"bounds":{"credentialSubject":{"lessSensitive":{"department":{"location":{"geo":{"lat":[{"min":-30,"max":50,"paramId":"random","protocol":"LegoGroth16"}],"long":[{"min":-10,"max":85,"paramId":"random","protocol":"LegoGroth16"}]}}}}}},"sigType":"Bls12381BBSSignatureDock2023"}],"attributeEqualities":[[[0,"credentialSubject.SSN"],[1,"credentialSubject.sensitive.SSN"],[2,"credentialSubject.sensitive.SSN"]],[[0,"credentialSubject.timeOfBirth"],[1,"credentialSubject.timeOfBirth"]],[[0,"credentialSubject.BMI"],[1,"credentialSubject.physical.BMI"]],[[0,"credentialSubject.score"],[1,"credentialSubject.score"]],[[0,"credentialSubject.userId"],[1,"credentialSubject.sensitive.userId"]]],"boundedPseudonyms":{},"unboundedPseudonyms":{}},"proof":"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","attributeCiphertexts":{"0":{"credentialSubject":{"SSN":["MwvzroUX4te6XLjPdg64cGk8v4BHiigRTYXsv2EwMhmbAmkgcheBPiq5Xhjph7QQRRr8KAnTfgitQ6AfuzPXPYmGmVMjfzW5My8omMUent9GrU8vP3aZQd4zCUWPXusSL7SRraN4SUE57K6GYHK251E21UECDW4GPcWLB2mzFEGLG5TSqVw4by91QZjVfBzbHNDMRWZ2kuazuLjNY8Lmo5S4TX4zzVHgvd53E45xX6n4h3ev4ULsySJ8tUJfjVfVgbq3UB8KtUAcdbh8YczjzGyosi7FzMrJ9QSHgnzxAoCexfzyMpYc66wCpLP4QxGe5yVLPFAF2ZVe9ER7XhuCH1N4hVS67q3w3S7oqjh8KRBH7nRrUNfztT3awjmhSRv1HpQG1CeDQmshnSHPox6BwcEkz21rFfdhN1HmawKJzHWKzRKJA36DVtiXQ3Xqaz71AS5p5hgPGPDnWA6vk6rxB9ZFd9G2jhfA62JyTidNZ3pL8yw63WX8tEqJw2pL4AjcxcbNZupAZPs9y51RuW5WaUWSzULV1PuvF4VxQ8oo5bqt1A9HwcADwtzGJrVjKAWaXWkjgNuK6sgQkxUd31qhZ7A6Z5LBwuyBM7aZFP4Vs4GtJi24zct8BBCyeN2r895NRHbrqvguPL8kg69aPbydk8CP12cmnmvkaVfjdLt5akM9Q7rujAtmnx6Ak6z6vCSEf9msANFnTm6hzHrMU2mxvDybHnpFM67PJ8faJsnvmyFM4Godtjbpc6Xt1zZ19fzw9tVMj2yYr9vkyFS1PejJ8v6R7VrC28T6m1W8kH9Tt81hgu297DjAvvkgwsDneyrkpkJQDupm3WJmPEzGjJ6LaCa9Tm2vWF13RuagxAcfLgSVMPGxBL59rypj9Bd1oHER4EH8YAAEfLcKMdZQ9KaA8N17JEjED8WAcd5GGEBWFgfh4CwcMeamWMATXtPaom7Vp7QkonjNhekHCGtac7vHMqrJFxUSid9Gf3ZftMFh133iefPsHnb9euYM5tVsdKX1DCtYzSoVigwkoRpfUeaqCdAJpVNLBGCZCWnK1p6BZ9ZiHcoKnE2oeEMQJsmGaCwL4GamNvynbRKTVpKSXSrpSgg4inKssch4G5XR4DAAAFgdhhGjFcC3zrCtvJcaSwPDBnyBoounTtnfEXahke2pn5125FkwXnSXFertZjw"]}},"1":{"credentialSubject":{"sensitive":{"userId":["JaTUUaVcgQfLKmz9t53ba3RzhCir7r7noTAvLbvuCiqyTGXFmwtnY5jPnqN795z6GAQYbFqtGpUgcfuBgTxz4evAqWwJpxYvAg6eBPiLzdKprnHyiuQFqGdDdJGHorZPB7XTSnpimDJTzJXe9HCoK8tjr9ay1wBpcm6vLeUh7FPU9aDTUG77x7vjvs6yurwLMBKsjNBNxgeVtoSb1VXYkQJacDR6ZPeHLdR8HnUvo6Lw6oX5J7FRoaDnwso7wDAVg9ZEHjdboYWdAgMxLPrRqZUYSa42EM5WCutjLwJ1mAoNbPBgxF5VZ27PJznfvbdZmDWztDm1Q3R9GJmYQw5vLXz4aifVTCUH57uXWU6rm595vHCt2pAKD26tPQtFmZBVGxLNF2FVbdEZb96rygftRACRaZGd5nRfUECt3x9mbELoABToRmiPG4Y3nC2sRop6SFJCMoPS1ovyEoK8XwbeeYHuH3KzxGSS4zMiraugiypuGokWwx5pqWFRybJhKLvvx5v9FEvipmkp3HioXPQq8FsKZKMYoVpoDj3NMF4othu6drv9VdZ87fT5NaoLpFbueDV4FrN7zFf7yMiFHBQsmWtXawf46LuangLM2YnPruPN3f8Z2rBAebnt553WEShLP8mxB6fLMYTp7eVgZUty76Swpt23KrJJnqmtXtKg2U6fwi1TxQURRanxyRdAW9gHjLXzM7dne6e8mnCNn43zVjKTjAsX8sCP7xqenDxJX5JVp8aZyNwV51mZgmLAGbx6ZF89w51Nu9cbfHGqzdBrU715xCX9T6tNczGPXvQRRhbMuWJYtNDUBuAKxSCHF9YQ522U6uzyFYY2Fis6AAVF2KAaxH9sheb48Zy7caBZb6GwhVmJpkw9C9NE5HEPRVHn6NmJQSv2nToHMqLyPuhxbb3rfVSo8bpxsfyEvBcstMKDUj53H1TVzPpSfxBkg8LYCA7Ehh6DR5ehD55QRmYw5BsYinqdSjM254fVU3FpcB67NSwzVT8qEvhiuc863KvbEFFWsdXc4aZcqrZ2zPEZi89fjkbWN1sJhaoBvZSeXMaGqD5ExFo29vJFAEez5tc5X64EvWxBcQHcQcfCxF1dHaJRzZ1qt8WaDJJ5jWQqXEKUjNdu4KPjtM9Zm3of8UJovpNpYLjMj2xBBETQzicX2gqEBLqwkEPD95c4auw"]}}}}} \ No newline at end of file diff --git a/tests/anonymous-credentials/serialized-objects/ps-presentation-0.10.0.json b/tests/anonymous-credentials/serialized-objects/ps-presentation-0.10.0.json index ac8d2286..4593ee57 100644 --- a/tests/anonymous-credentials/serialized-objects/ps-presentation-0.10.0.json +++ b/tests/anonymous-credentials/serialized-objects/ps-presentation-0.10.0.json @@ -1 +1 @@ -{"version":"0.10.0","nonce":null,"spec":{"credentials":[{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"},\"email\":{\"type\":\"string\"},\"fname\":{\"type\":\"string\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"lname\":{\"type\":\"string\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"secret\":{\"type\":\"string\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lname":"Smith"}},"bounds":{"credentialSubject":{"timeOfBirth":[{"min":1662010838000,"max":1662010856123,"paramId":"random","protocol":"LegoGroth16"}],"BMI":[{"min":10,"max":40,"paramId":"random","protocol":"LegoGroth16"}],"score":[{"min":-40.5,"max":60.7,"paramId":"random","protocol":"LegoGroth16"}]}},"verifiableEncryptions":{"credentialSubject":{"SSN":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}},"sigType":"Bls12381PSSignatureDock2023"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"isbool\":{\"type\":\"boolean\"},\"lname\":{\"type\":\"string\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"},\"physical\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"secret\":{\"type\":\"string\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"}},\"type\":\"object\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","location":{"country":"USA"}}},"verifiableEncryptions":{"credentialSubject":{"sensitive":{"userId":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}}},"sigType":"Bls12381PSSignatureDock2023"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialStatus\":{\"properties\":{\"id\":{\"type\":\"string\"},\"revocationCheck\":{\"type\":\"string\"},\"revocationId\":{\"type\":\"string\"},\"type\":{\"type\":\"string\"}},\"type\":\"object\"},\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"lessSensitive\":{\"properties\":{\"department\":{\"properties\":{\"location\":{\"properties\":{\"geo\":{\"properties\":{\"lat\":{\"minimum\":-90,\"multipleOf\":0.001,\"type\":\"number\"},\"long\":{\"minimum\":-180,\"multipleOf\":0.001,\"type\":\"number\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"lname\":{\"type\":\"string\"},\"rank\":{\"minimum\":0,\"type\":\"integer\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"phone\":{\"type\":\"string\"},\"very\":{\"properties\":{\"secret\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lessSensitive":{"location":{"country":"USA"},"department":{"location":{"name":"Somewhere"}}}}},"status":{"id":"dock:accumulator:accumId123","type":"DockVBAccumulator2022","revocationCheck":"membership","accumulated":"5iYSR7j6eCT2nvmKMGE3f88CQ73crNhcesj1Nq6JwkqbvCzuyR9qNYWLpvyJU1h27d","extra":{"blockNo":2010334}},"bounds":{"credentialSubject":{"lessSensitive":{"department":{"location":{"geo":{"lat":[{"min":-30,"max":50,"paramId":"random","protocol":"LegoGroth16"}],"long":[{"min":-10,"max":85,"paramId":"random","protocol":"LegoGroth16"}]}}}}}},"sigType":"Bls12381PSSignatureDock2023"}],"attributeEqualities":[[[0,"credentialSubject.SSN"],[1,"credentialSubject.sensitive.SSN"],[2,"credentialSubject.sensitive.SSN"]],[[0,"credentialSubject.timeOfBirth"],[1,"credentialSubject.timeOfBirth"]],[[0,"credentialSubject.BMI"],[1,"credentialSubject.physical.BMI"]],[[0,"credentialSubject.score"],[1,"credentialSubject.score"]],[[0,"credentialSubject.userId"],[1,"credentialSubject.sensitive.userId"]]],"boundedPseudonyms":{},"unboundedPseudonyms":{}},"proof":"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","attributeCiphertexts":{"0":{"credentialSubject":{"SSN":["He1KNaYCAeZ5bQQX7f6i1T5aUeX2AZDtVkKY6ARc5d8zPkHveXTZ3T3spQYeDUHDNJKCHNT3AAeupUDsFgwSopchD1nRkLyX96JF99UNHXEGHqsVfiW1JqqHeCPzwiJmUEoPdU18vqpni1cxqzm696K9UcJSnEZaNuWhzchQY5btQKRinrjBkJdYboooEbVw8aUSrYS1JiPHk8BJXTgy9cdzWE3eFA6zaJyv2gZMBFoyE4a3bR5bnvaEgdhLp4hXusTGMn8ApVFERNWEk4CdwCTH4dgkvqaATCvJ2XZz51TjuCD3WUJaNWEtPTMYLnmQMfm2rmUtDQWtexEs6DHyQ8xCkWJTsjuVPBxj2Hzwj9sSnzseEXEctt1PcDzy1VHDzfdPccxdKNvVT2Z4pRJb2kovYu5bqUSoruh78EWu5tUGEhu1apTey6M77nE29mvTr79nr4SNFRiyM7bzQZppaf6sm39B2GRyQhfnqAZ2XMM6bEYpJMUfTnKjJoZ9aiovHjSZ5RB72TxbFEPRqavv8BEweffbgEfnFRXWqcHQ6LacGzT3NMptYkyH3yGm7TJPJV6ZVihspZLWdSwiXutZzVyGJm5CtQrNPyhtDHVhDGAiBgw6FPsRfYXdbobc2U6bnpTFmKGz6HMBGfE61YX7DqWyQADUd35H77er2AhY1rmD7L5yMmG4tKUAnf6ZY46RRMZgQY45xXYDS2Rz697xyGAaz7UqRcdn2CtXErc5HMJhBbcNpJwVTotc3m65KCejLufPoaR6LczdU4S9kQj37G7RFzdN9e7UmUDt32jsQXceTSd3cZk6faJswD7cBg3zz7Qf1UbrjBLoVwTTQiwC8dXKBW6EnUG4USNzqAJc71ynEdX551uRCSHC9SNLtRdYgsJ9zUCEV7rXUkxESMQwC9AaDcCHMN4T4eQ4CUhKxCDTJVieoivh24bT7aT6aPJx5SxVFYFR1NXiB6bbchaiTGU8NsXehfKDdVNy8TuQd88p8y8RAc4VRQGSK7QGyh1BjPU6JJSqogWa2ZBAXDnF6yAWDg5e4kYa4df1SkXuYZY3ZiqqkztrUsjLgc7jQ7EB1hdEdxxvmEgT47pjQrWtsRWnHKNxusUwpGK51H7RgbJA36Z9C2M6wc2eLdXEoiQxDX5VCh8UGBWAMs1bhEtonxvrHuZz6vS6qnMMemQ"]}},"1":{"credentialSubject":{"sensitive":{"userId":["MHEiKegAGS8yUmMjMZxpmag3XD4KkLat1XXcmwWLPVsRhMy4B2GQimP864vs45erW6bdhpdAoTQMeUusgm8kD9REZPtTi8ugsiwezyiDzEg8yFJtZXp26dEMBqRLWY4MMyAQ7bGZvV7e5Xk1V1HwTbuhYNqnT7ya8Hgcyfe7yY2d2tjvCpKjq5oZP33HkvGDFiAAwegq31BuiajegKwJmHZgVAyQrKyjAnVhzgqxdSVxwfZMvAEdNGZeHfUeb6ncbdhEQdu15WNrBFJbqP6e2UTsJqhmnjPnSdCzKxWU2kraJFv14zRdZ6goD7s9VnNDYPn14FdnFvr4fPUk6v8HmsK6JWwLDZENY5fZCaffQ3bNbaoMg7p9se1MJJ8WAyoAqLDjVs3n4BL28NDZFoiovhVQM553tnGnGzHK88pWnRN4jjDVBctejfVYGWoAvB6eMrZLLRciG8HAwLt3NMTV4SXmWAguMuSWT6EMTLJFJaCZGwMcoqq1N9ExNSuqJMPFpgsWL2RcVzCYpsLXjPuzq2LquiM9ez6aTUKPs4YrSG56QquJ6AcqzM9zCKz8pAX5E3gmj21JEqskTBuJyYXuqfHUL56VQZ8P4TQ5kc8jiANbqFhHHYbWctWYNQPp4zMZrfwKK7SLCdsQCmTun2enJt6g4tBMMSixFowL3JAGQ4TK1mdwFxt6EMNPgSkNdHPAchAdgLQAhd18KtSa3X6KRS2AxmpBpY5mJf3yjssFgHrdyhNCW5T7qYKyVM7cuoF6NQx6Yd8J2CsQwn3718GH4qHSoV2j7fxaSDyESadAtvm8JWMAE5mNXbjcZskGqbZzjvVRnQKWTK4DsBSXciR1KnFJrRsmsKFkJ3KuYTBRe2kLoTcuup6N1y1oWTkEwhvwpJvsmgafZwjzJHu52q48w9aT78try5NpiHFSarU4cWe8GCp5118Ma5Af8ihGRXeUdk9r5bYeFDx4VVr5nQwjmmggfmBjgh6Et4nvxxtXpFnCjMAZge3BosHKB5r11NV83MZrp2pNEP4KFjKW6N2END9RTEbgrQJ9mToH4qPrjKvh7PS8vVhWnaAXqW929MX4V768LKYaUtnzzzuUG2cvrZ18p3QNoszgujEDvUJfUiyXL46D46MXuZ5H8RUw2rKjWTbnUSTYVyjAxAxEZCQtbZMypdoEMuDUNti3QPs"]}}}}} \ No newline at end of file +{"version":"0.10.0","nonce":null,"spec":{"credentials":[{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"},\"email\":{\"type\":\"string\"},\"fname\":{\"type\":\"string\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"lname\":{\"type\":\"string\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"secret\":{\"type\":\"string\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lname":"Smith"}},"bounds":{"credentialSubject":{"timeOfBirth":[{"min":1662010838000,"max":1662010856123,"paramId":"random","protocol":"LegoGroth16"}],"BMI":[{"min":10,"max":40,"paramId":"random","protocol":"LegoGroth16"}],"score":[{"min":-40.5,"max":60.7,"paramId":"random","protocol":"LegoGroth16"}]}},"verifiableEncryptions":{"credentialSubject":{"SSN":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}},"sigType":"Bls12381PSSignatureDock2023"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"isbool\":{\"type\":\"boolean\"},\"lname\":{\"type\":\"string\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"},\"physical\":{\"properties\":{\"BMI\":{\"minimum\":0,\"multipleOf\":0.01,\"type\":\"number\"},\"height\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"},\"weight\":{\"minimum\":0,\"multipleOf\":0.1,\"type\":\"number\"}},\"type\":\"object\"},\"score\":{\"minimum\":-100,\"multipleOf\":0.1,\"type\":\"number\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"secret\":{\"type\":\"string\"},\"userId\":{\"$ref\":\"#/definitions/encryptableCompString\"}},\"type\":\"object\"},\"timeOfBirth\":{\"minimum\":0,\"type\":\"integer\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","location":{"country":"USA"}}},"verifiableEncryptions":{"credentialSubject":{"sensitive":{"userId":[{"chunkBitSize":16,"commitmentGensId":"random-1","encryptionKeyId":"random-2","snarkKeyId":"random-3","protocol":"SAVER"}]}}},"sigType":"Bls12381PSSignatureDock2023"},{"version":"0.7.0","schema":{"details":"{\"jsonSchema\":{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"definitions\":{\"encryptableCompString\":{\"type\":\"string\"},\"encryptableString\":{\"type\":\"string\"}},\"properties\":{\"credentialStatus\":{\"properties\":{\"id\":{\"type\":\"string\"},\"revocationCheck\":{\"type\":\"string\"},\"revocationId\":{\"type\":\"string\"},\"type\":{\"type\":\"string\"}},\"type\":\"object\"},\"credentialSubject\":{\"properties\":{\"fname\":{\"type\":\"string\"},\"lessSensitive\":{\"properties\":{\"department\":{\"properties\":{\"location\":{\"properties\":{\"geo\":{\"properties\":{\"lat\":{\"minimum\":-90,\"multipleOf\":0.001,\"type\":\"number\"},\"long\":{\"minimum\":-180,\"multipleOf\":0.001,\"type\":\"number\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"name\":{\"type\":\"string\"}},\"type\":\"object\"},\"location\":{\"properties\":{\"city\":{\"type\":\"string\"},\"country\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"lname\":{\"type\":\"string\"},\"rank\":{\"minimum\":0,\"type\":\"integer\"},\"sensitive\":{\"properties\":{\"SSN\":{\"$ref\":\"#/definitions/encryptableString\"},\"email\":{\"type\":\"string\"},\"phone\":{\"type\":\"string\"},\"very\":{\"properties\":{\"secret\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"}},\"type\":\"object\"},\"proof\":{\"properties\":{\"type\":{\"type\":\"string\"}},\"type\":\"object\"}},\"type\":\"object\"},\"parsingOptions\":{\"defaultDecimalPlaces\":0,\"defaultMinimumDate\":-17592186044415,\"defaultMinimumInteger\":-4294967295,\"useDefaults\":false}}","id":"data:application/json;charset=utf-8,","type":"JsonSchemaValidator2018","version":"0.5.0"},"revealedAttributes":{"credentialSubject":{"fname":"John","lessSensitive":{"location":{"country":"USA"},"department":{"location":{"name":"Somewhere"}}}}},"status":{"id":"dock:accumulator:accumId123","type":"DockVBAccumulator2022","revocationCheck":"membership","accumulated":"5iYSR7j6eCT2nvmKMGE3f88CQ73crNhcesj1Nq6JwkqbvCzuyR9qNYWLpvyJU1h27d","extra":{"blockNo":2010334}},"bounds":{"credentialSubject":{"lessSensitive":{"department":{"location":{"geo":{"lat":[{"min":-30,"max":50,"paramId":"random","protocol":"LegoGroth16"}],"long":[{"min":-10,"max":85,"paramId":"random","protocol":"LegoGroth16"}]}}}}}},"sigType":"Bls12381PSSignatureDock2023"}],"attributeEqualities":[[[0,"credentialSubject.SSN"],[1,"credentialSubject.sensitive.SSN"],[2,"credentialSubject.sensitive.SSN"]],[[0,"credentialSubject.timeOfBirth"],[1,"credentialSubject.timeOfBirth"]],[[0,"credentialSubject.BMI"],[1,"credentialSubject.physical.BMI"]],[[0,"credentialSubject.score"],[1,"credentialSubject.score"]],[[0,"credentialSubject.userId"],[1,"credentialSubject.sensitive.userId"]]],"boundedPseudonyms":{},"unboundedPseudonyms":{}},"proof":"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","attributeCiphertexts":{"0":{"credentialSubject":{"SSN":["KJvyJ9W2hwFUS5V2v8eishfdUa85CvpSczPoE9tRdAUuJhLPajt16PpV3H6Skwr9rrV7zM3wtvavS9dKESfULsNhVkqYahcGf2qUTHeBq4NkX5Q4vJhdy5NNiAwXhqbNRRMT5PTQx46fUrRuuXrKPU9niompAJ5SLwWyPfkTyAAKLQmJ84Cd24TGo2dgmx2zYqv6K6N9DYVERJDJ1jUhhghn2N84Lat5Cd8TNW7zp9CZj3DE9zXjctu2KzZsQaMMfDe2X48q9MMQ8ivtBDgkj2dMJUpRWU6memEUCAv9ZY5sqFKHEHHmCondBsz15LBEJyTnHyWzQNB9Na76pmcC5zCw1SRf5TP9W2XiC4ojL1ifBDZaNucE44aZPjFJi8mgsc314wydb3WXGw4SJcJvmw9bpCTM2d9Tr1fawQktYWU94ErsgGf1xMrGXvGQanyLuaAQwansmRkqjdMJaMV32Ut5yT27c2BftBb5vRxNBe6TS8oXRMwsvKggghGuTg8ZQdLbg36r5Ly31YgV6xJCH3aYCskWmb5vQV5wQNAQr7mEVWd4fDd6sp8W3SaHPrQxkMZtr8RwRfchaxFgQGANnvwka7Cw15uUKCrVGz1d9TKUD5bkVMsrLUh53uXrFWyirN1GzNjVcq2rJPxhV5LKnZ7x33ehLLFWVaNNSY1TKNMe2rsSFuA6mfq8P8v9regAjzPzo5nVTWT2RpV6xt3mGJ2WcQGw8NUSdmJAxD7k8JXPX3QBNurtpnqgGuqJxEncr9nuupSu41suhY8UHgyKPRSyGFE8zVmoscpBXkQPkgGrjErNJaMuMtVv38Q1bBaqcQ9ki1cLtPcyRqRsX8tYvctftiDwHQVFv7ecmRbVighQ3CJuRPiXDXmWVPDYN9DUyzTgPfX1AqFF7KRsjZWoPko9MTLVhJMHPyeD3T1fLCxCo9THHaN3nf75Chp8ULEjVqjEHxCp8ESs9j6D1etZXgrN8Ei1mQRPxzngML8uzC1uLDmCtBg5aCBirr2iLa4ux4dekwyAGBH2jhqgMUq6cqXQBc731nRzW4u3r5FoinSwbU5RHa9mJ5QYaY5we5gsgJCFoAVbV89QvXgHQxtqVDFz1ECyz7z7s2hfmRUA2t88d4kECH34cmMqRhSDq5JMKhYr1NGMjrAaheA886BFToUu6gQb9eqmcX5EDQ6"]}},"1":{"credentialSubject":{"sensitive":{"userId":["N12FzY3Kt49pXbu1BsSNzQAbD3SgJgHHtdQK46hH4qKKe4NgTFoMTd3WmWfThtCMGj2iwwtp3mLq2dm13UmsFddzqCFqX9FJQHYuxSEd3Yhthdi4NrnAyd857CjiTcEestFAVFDMQLe57Ah3pA1arFK3rEa9j1tJxxWW5N6YsNAZpJCKFi6uFrmFb1BMEq8qPLPSzvtQCEMHc1NeJSsX7ZHo9Qk3kJpn4TsyJPY18KEJzhm8ScCQp8muZUmZBiHVvG1V7VzeYLXNFqAsLH2Q8XoZ7Z5yyZaF8y7bpisBgb2Vh5EJg3jyQmUVE3j5shFND6Tcju7oMikAPdUv1uGUJLqUZULUazZNkppuzs7R8C7GtHfinob32GZeWQHBNcxGYnYQGvuBYk15BfU53Nc1QgTYo8cE54vCeuvT6YvLSjBD8VRALMCcQ6qczKfnYSjSimvxwy6G65dc2PWZ5meahYf2XKYm1vykeaQ8vqq2YpTM57ooR7R849oU2AsEHhxNLipRzvRgFktBzxY8RF8ihhs7PigDrxsXVfcYWoXabbKxNxG14x8ZdSVMz8nyKxPDvo3u7ETPeZNSSA2nRq4avhikatUwwvbCUGSSQ7bx5mjSpJgs6fkw89nviSM8Vv4Hm6hsYHg2z5jQEyPFoUg7ddHjjWzf5vRsgFVZX1WeUM7mXMzkyq8QiNviRL8HnXU92QPMo2WhrBUQnzFaWrTtJzYQyeMG2ZPRCxzgM8pBVKP8yk5iJ7UvSdVaVAjS6mKoPuS6REyivJSJnWRtnShoWN6iJakKk1QknH8hUwVaAxhnPUcRVRHdaUoURMkMnQvYHiAFNGapADgufiEoX6EU8LE8BkxGtunG2WoqiUYtZTBRmMo9rMVasgHw4uzuuB6UhVEMWoLGuCgSYZ3SxiBkwAu3b4t5uwET8JBCfsAtsRYymWGE4sE5ikow8sqCxvsSr8WvWHRf1JAjEamUCiFRToNo6rwgcxSPDxe7nsf9evXbCeWUERhELvCecQxHA2SNzJyf8ZiNC1GoJXEdYpiipdE3vf8T9RordPpuPCkmg7pwjhqz26vDJSspBGqPdvE6LUbXtRirVB1bGnKUBmmnjFZXapwAZa5v8kZktETsPdXGL8Pmu53FBJyapyBW8a7TMdUVNW2rpkkzC8yLnncycKE5jjvPKTwA17Gstpt"]}}}}} \ No newline at end of file diff --git a/tests/anonymous-credentials/utils.ts b/tests/anonymous-credentials/utils.ts index a446f5b4..a90efd07 100644 --- a/tests/anonymous-credentials/utils.ts +++ b/tests/anonymous-credentials/utils.ts @@ -9,7 +9,7 @@ import { dockSaverEncryptionGensUncompressed, EMPTY_SCHEMA_ID, IAccumulatorState, IEmbeddedJsonSchema, - IJsonSchema, PositiveAccumulator, + IJsonSchema, MessageEncoder, PositiveAccumulator, PredicateParamType, PseudonymBases, REV_ID_STR, SaverCiphertext, @@ -638,10 +638,11 @@ export function checkCiphertext( cts = [cts]; } cts.forEach((ciphertext) => { - let decrypted = SaverDecryptor.decryptCiphertext(ciphertext, saverSk, saverDk, saverVerifyingKey, chunkBitSize); + const decrypted = SaverDecryptor.decryptCiphertext(ciphertext, saverSk, saverDk, saverVerifyingKey, chunkBitSize); expect(decrypted.message).toEqual( credential.schema?.encoder.encodeMessageConstantTime(`${SUBJECT_STR}.${attrName}`, _.get(credential.subject, attrName)) ); + expect(MessageEncoder.reversibleDecodeStringForSigning(decrypted.message)).toEqual(_.get(credential.subject, attrName)); // Decryptor shares the decryption result with verifier which the verifier can check for correctness. expect( diff --git a/tests/frost-dkg.spec.ts b/tests/frost-dkg.spec.ts index 0a4caf92..29242980 100644 --- a/tests/frost-dkg.spec.ts +++ b/tests/frost-dkg.spec.ts @@ -1,6 +1,6 @@ import { generateRandomG1Element, generateRandomG2Element } from 'crypto-wasm-new'; import { runFrostKeygen, stringToBytes } from './utils'; -import { ParticipantG1, ParticipantG2 } from '../src/frost-dkg'; +import { FrostDkgParticipantG1, FrostDkgParticipantG2 } from '../src/frost-dkg'; import { PublicKeyBase } from '../src/types'; import { initializeWasm } from '../src'; @@ -18,9 +18,9 @@ describe('Frost DKG', () => { const threshold = 3; const total = 5; const protocolId = stringToBytes('test DKG in G1'); - const participants: ParticipantG1[] = []; + const participants: FrostDkgParticipantG1[] = []; for (let i = 1; i <= total; i++) { - participants.push(new ParticipantG1(i, threshold, total, protocolId)) + participants.push(new FrostDkgParticipantG1(i, threshold, total, protocolId)) } runFrostKeygen(participants, pkBaseG1) }) @@ -29,9 +29,9 @@ describe('Frost DKG', () => { const threshold = 3; const total = 5; const protocolId = stringToBytes('test DKG in G2'); - const participants: ParticipantG2[] = []; + const participants: FrostDkgParticipantG2[] = []; for (let i = 1; i <= total; i++) { - participants.push(new ParticipantG2(i, threshold, total, protocolId)); + participants.push(new FrostDkgParticipantG2(i, threshold, total, protocolId)); } runFrostKeygen(participants, pkBaseG2) }) diff --git a/tests/scheme.ts b/tests/scheme.ts index 546bc4b6..b49a2a5d 100644 --- a/tests/scheme.ts +++ b/tests/scheme.ts @@ -41,7 +41,12 @@ import { PS_SIGNATURE_PARAMS_LABEL_BYTES, BBDT16_MAC_PARAMS_LABEL_BYTES, getBBDT16StatementForBlindMacRequest, - getBBDT16WitnessForBlindMacRequest, BBDT16CredentialBuilder, BBDT16Credential, BBDT16KeypairG1, BBDT16MacPublicKeyG1 + getBBDT16WitnessForBlindMacRequest, + BBDT16CredentialBuilder, + BBDT16Credential, + BBDT16KeypairG1, + BBDT16MacPublicKeyG1, + BBS_CRED_PROOF_TYPE, BBS_PLUS_CRED_PROOF_TYPE, PS_CRED_PROOF_TYPE, BBDT16_CRED_PROOF_TYPE } from '../src'; import { BBDT16BlindMac, BBDT16Mac, BBDT16MacParams, BBDT16MacSecretKey } from '../src'; @@ -68,6 +73,7 @@ export let Scheme: string = process.env.TEST_SIGNATURE_SCHEME || 'BBS', buildVerifierStatementFromSetupParamsRef, CredentialBuilder, Credential, + CredentialProofType, encodeMessageForSigningIfPS: (msg: Uint8Array) => Uint8Array, encodeMessageForSigningIfNotPS: (msg: Uint8Array) => Uint8Array, isBBS = () => false, @@ -97,6 +103,7 @@ switch (Scheme) { getWitnessForBlindSigRequest = getBBSWitnessForBlindSigRequest; CredentialBuilder = BBSCredentialBuilder; Credential = BBSCredential; + CredentialProofType = BBS_CRED_PROOF_TYPE; encodeMessageForSigningIfPS = (msg) => msg; encodeMessageForSigningIfNotPS = encodeMessageForSigningInConstantTime; SignatureLabelBytes = BBS_SIGNATURE_PARAMS_LABEL_BYTES; @@ -121,6 +128,7 @@ switch (Scheme) { getWitnessForBlindSigRequest = getBBSPlusWitnessForBlindSigRequest; CredentialBuilder = BBSPlusCredentialBuilder; Credential = BBSPlusCredential; + CredentialProofType = BBS_PLUS_CRED_PROOF_TYPE; SignatureLabelBytes = BBS_PLUS_SIGNATURE_PARAMS_LABEL_BYTES; encodeMessageForSigningIfPS = (msg) => msg; encodeMessageForSigningIfNotPS = encodeMessageForSigningInConstantTime; @@ -145,6 +153,7 @@ switch (Scheme) { getWitnessForBlindSigRequest = getPSWitnessesForBlindSigRequest; CredentialBuilder = PSCredentialBuilder; Credential = PSCredential; + CredentialProofType = PS_CRED_PROOF_TYPE; SignatureLabelBytes = PS_SIGNATURE_PARAMS_LABEL_BYTES; encodeMessageForSigningIfPS = encodeMessageForSigningInConstantTime; encodeMessageForSigningIfNotPS = (msg) => msg; @@ -170,6 +179,7 @@ switch (Scheme) { getWitnessForBlindSigRequest = getBBDT16WitnessForBlindMacRequest; CredentialBuilder = BBDT16CredentialBuilder; Credential = BBDT16Credential; + CredentialProofType = BBDT16_CRED_PROOF_TYPE; SignatureLabelBytes = BBDT16_MAC_PARAMS_LABEL_BYTES; encodeMessageForSigningIfPS = (msg) => msg; encodeMessageForSigningIfNotPS = encodeMessageForSigningInConstantTime; diff --git a/tests/threshold-sigs.spec.ts b/tests/threshold-sigs.spec.ts index 6fc7881e..8c5176a8 100644 --- a/tests/threshold-sigs.spec.ts +++ b/tests/threshold-sigs.spec.ts @@ -8,7 +8,7 @@ import { BBSSignatureParams, initializeWasm } from '../src'; -import { ParticipantG2 } from '../src/frost-dkg'; +import { FrostDkgParticipantG2 } from '../src/frost-dkg'; import { BaseOTOutput, Challenges, @@ -18,7 +18,7 @@ import { HashedKeys, Message1, Message2, - Participant as BaseOTParticipant, + BaseOTParticipant as BaseOTParticipant, ReceiverPublicKey, Responses, SenderPublicKey, @@ -57,18 +57,18 @@ describe('Threshold BBS+ and BBS', () => { paramsBbsPlus = BBSPlusSignatureParamsG1.generate(messageCount, label); paramsBbs = BBSSignatureParams.generate(messageCount, label); - const keygenBbsPlus: ParticipantG2[] = []; - const keygenBbs: ParticipantG2[] = []; + const keygenBbsPlus: FrostDkgParticipantG2[] = []; + const keygenBbs: FrostDkgParticipantG2[] = []; const protocolIdBbsPlus = stringToBytes('DKG for BBS+'); const protocolIdBbs = stringToBytes('DKG for BBS'); for (let i = 1; i <= total; i++) { - keygenBbsPlus.push(new ParticipantG2(i, threshold, total, protocolIdBbsPlus)); - keygenBbs.push(new ParticipantG2(i, threshold, total, protocolIdBbs)); + keygenBbsPlus.push(new FrostDkgParticipantG2(i, threshold, total, protocolIdBbsPlus)); + keygenBbs.push(new FrostDkgParticipantG2(i, threshold, total, protocolIdBbs)); } // The public key in both BBS+ and BBS uses the elliptic curve point from signature params - const pkBaseBbsPlus = ParticipantG2.generatePublicKeyBaseFromBbsPlusParams(paramsBbsPlus); - const pkBaseBbs = ParticipantG2.generatePublicKeyBaseFromBbsParams(paramsBbs); + const pkBaseBbsPlus = FrostDkgParticipantG2.generatePublicKeyBaseFromBbsPlusParams(paramsBbsPlus); + const pkBaseBbs = FrostDkgParticipantG2.generatePublicKeyBaseFromBbsParams(paramsBbs); // All participants generate their secret key, public key and the threshold key const [s1, p1, t1] = runFrostKeygen(keygenBbsPlus, pkBaseBbsPlus); diff --git a/tests/utils.ts b/tests/utils.ts index 7b8310ec..d0ca8ace 100644 --- a/tests/utils.ts +++ b/tests/utils.ts @@ -12,7 +12,7 @@ import { ParsedR1CSFile, PublicKeyBase } from '../src'; -import { Participant, Round1Msg, Share } from '../src/frost-dkg'; +import { FrostDkgParticipant, Round1Msg, Share } from '../src/frost-dkg'; import { buildProverStatement, buildVerifierStatement, @@ -158,7 +158,7 @@ export function getBoundCheckSnarkKeys( return [snarkProvingKey, snarkVerifyingKey]; } -export function runFrostKeygen(participants: Participant[], pkBase: PublicKeyBase): [Uint8Array[], Uint8Array[], Uint8Array] { +export function runFrostKeygen(participants: FrostDkgParticipant[], pkBase: PublicKeyBase): [Uint8Array[], Uint8Array[], Uint8Array] { const msgs = new Map(); for (let i = 0; i < participants.length; i++) { expect(participants[i].hasStarted()).toEqual(false); diff --git a/yarn.lock b/yarn.lock index 1cbccb56..f4c8cb66 100644 --- a/yarn.lock +++ b/yarn.lock @@ -837,6 +837,48 @@ "@nodelib/fs.scandir" "2.1.5" fastq "^1.6.0" +"@shikijs/core@1.22.2": + version "1.22.2" + resolved "https://registry.yarnpkg.com/@shikijs/core/-/core-1.22.2.tgz#9c22bd4cc8a4d6c062461cfd35e1faa6c617ca25" + integrity sha512-bvIQcd8BEeR1yFvOYv6HDiyta2FFVePbzeowf5pPS1avczrPK+cjmaxxh0nx5QzbON7+Sv0sQfQVciO7bN72sg== + dependencies: + "@shikijs/engine-javascript" "1.22.2" + "@shikijs/engine-oniguruma" "1.22.2" + "@shikijs/types" "1.22.2" + "@shikijs/vscode-textmate" "^9.3.0" + "@types/hast" "^3.0.4" + hast-util-to-html "^9.0.3" + +"@shikijs/engine-javascript@1.22.2": + version "1.22.2" + resolved "https://registry.yarnpkg.com/@shikijs/engine-javascript/-/engine-javascript-1.22.2.tgz#62e90dbd2ed1d78b972ad7d0a1f8ffaaf5e43279" + integrity sha512-iOvql09ql6m+3d1vtvP8fLCVCK7BQD1pJFmHIECsujB0V32BJ0Ab6hxk1ewVSMFA58FI0pR2Had9BKZdyQrxTw== + dependencies: + "@shikijs/types" "1.22.2" + "@shikijs/vscode-textmate" "^9.3.0" + oniguruma-to-js "0.4.3" + +"@shikijs/engine-oniguruma@1.22.2": + version "1.22.2" + resolved "https://registry.yarnpkg.com/@shikijs/engine-oniguruma/-/engine-oniguruma-1.22.2.tgz#b12a44e3faf486e19fbcf8952f4b56b9b9b8d9b8" + integrity sha512-GIZPAGzQOy56mGvWMoZRPggn0dTlBf1gutV5TdceLCZlFNqWmuc7u+CzD0Gd9vQUTgLbrt0KLzz6FNprqYAxlA== + dependencies: + "@shikijs/types" "1.22.2" + "@shikijs/vscode-textmate" "^9.3.0" + +"@shikijs/types@1.22.2": + version "1.22.2" + resolved "https://registry.yarnpkg.com/@shikijs/types/-/types-1.22.2.tgz#695a283f19963fe0638fc2646862ba5cfc4623a8" + integrity sha512-NCWDa6LGZqTuzjsGfXOBWfjS/fDIbDdmVDug+7ykVe1IKT4c1gakrvlfFYp5NhAXH/lyqLM8wsAPo5wNy73Feg== + dependencies: + "@shikijs/vscode-textmate" "^9.3.0" + "@types/hast" "^3.0.4" + +"@shikijs/vscode-textmate@^9.3.0": + version "9.3.0" + resolved "https://registry.yarnpkg.com/@shikijs/vscode-textmate/-/vscode-textmate-9.3.0.tgz#b2f1776e488c1d6c2b6cd129bab62f71bbc9c7ab" + integrity sha512-jn7/7ky30idSkd/O5yDBfAnVt+JJpepofP/POZ1iMOxK59cOfqIgg/Dj0eFsjOTMw+4ycJN0uhZH/Eb0bs/EUA== + "@sinclair/typebox@^0.25.16": version "0.25.24" resolved "https://registry.yarnpkg.com/@sinclair/typebox/-/typebox-0.25.24.tgz#8c7688559979f7079aacaf31aa881c3aa410b718" @@ -921,6 +963,13 @@ dependencies: "@types/node" "*" +"@types/hast@^3.0.0", "@types/hast@^3.0.4": + version "3.0.4" + resolved "https://registry.yarnpkg.com/@types/hast/-/hast-3.0.4.tgz#1d6b39993b82cea6ad783945b0508c25903e15aa" + integrity sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ== + dependencies: + "@types/unist" "*" + "@types/istanbul-lib-coverage@*", "@types/istanbul-lib-coverage@^2.0.0", "@types/istanbul-lib-coverage@^2.0.1": version "2.0.4" resolved "https://registry.yarnpkg.com/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.4.tgz#8467d4b3c087805d63580480890791277ce35c44" @@ -968,6 +1017,13 @@ resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.14.195.tgz#bafc975b252eb6cea78882ce8a7b6bf22a6de632" integrity sha512-Hwx9EUgdwf2GLarOjQp5ZH8ZmblzcbTBC2wtQWNKARBSxM9ezRIAUpeDTgoQRAFB0+8CNWXVA9+MaSOzOF3nPg== +"@types/mdast@^4.0.0": + version "4.0.4" + resolved "https://registry.yarnpkg.com/@types/mdast/-/mdast-4.0.4.tgz#7ccf72edd2f1aa7dd3437e180c64373585804dd6" + integrity sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA== + dependencies: + "@types/unist" "*" + "@types/node@*": version "18.8.5" resolved "https://registry.yarnpkg.com/@types/node/-/node-18.8.5.tgz#6a31f820c1077c3f8ce44f9e203e68a176e8f59e" @@ -993,6 +1049,11 @@ resolved "https://registry.yarnpkg.com/@types/stack-utils/-/stack-utils-2.0.1.tgz#20f18294f797f2209b5f65c8e3b5c8e8261d127c" integrity sha512-Hl219/BT5fLAaz6NDkSuhzasy49dwQS/DSdu4MdggFB8zcXv7vflBI3xp7FEmkmdDkBUI2bPUNeMttp2knYdxw== +"@types/unist@*", "@types/unist@^3.0.0": + version "3.0.3" + resolved "https://registry.yarnpkg.com/@types/unist/-/unist-3.0.3.tgz#acaab0f919ce69cce629c2d4ed2eb4adc1b6c20c" + integrity sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q== + "@types/yargs-parser@*": version "21.0.0" resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-21.0.0.tgz#0c60e537fa790f5f9472ed2776c2b71ec117351b" @@ -1089,6 +1150,11 @@ "@typescript-eslint/types" "5.59.9" eslint-visitor-keys "^3.3.0" +"@ungap/structured-clone@^1.0.0": + version "1.2.0" + resolved "https://registry.yarnpkg.com/@ungap/structured-clone/-/structured-clone-1.2.0.tgz#756641adb587851b5ccb3e095daf27ae581c8406" + integrity sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ== + abort-controller@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/abort-controller/-/abort-controller-3.0.0.tgz#eaf54d53b62bae4138e809ca225c8439a6efb392" @@ -1309,6 +1375,13 @@ brace-expansion@^1.1.7: balanced-match "^1.0.0" concat-map "0.0.1" +brace-expansion@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-2.0.1.tgz#1edc459e0f0c548486ecf9fc99f2221364b9a0ae" + integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA== + dependencies: + balanced-match "^1.0.0" + braces@^3.0.2: version "3.0.2" resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107" @@ -1400,6 +1473,11 @@ canonicalize@^1.0.1: resolved "https://registry.yarnpkg.com/canonicalize/-/canonicalize-1.0.8.tgz#24d1f1a00ed202faafd9bf8e63352cd4450c6df1" integrity sha512-0CNTVCLZggSh7bc5VkX5WWPWO+cyZbNd07IHIsSXLia/eAq+r836hgk+8BKoEh7949Mda87VUOitx5OddVj64A== +ccount@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/ccount/-/ccount-2.0.1.tgz#17a3bf82302e0870d6da43a01311a8bc02a3ecf5" + integrity sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg== + chalk@^2.0.0: version "2.4.2" resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424" @@ -1422,6 +1500,16 @@ char-regex@^1.0.2: resolved "https://registry.yarnpkg.com/char-regex/-/char-regex-1.0.2.tgz#d744358226217f981ed58f479b1d6bcc29545dcf" integrity sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw== +character-entities-html4@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/character-entities-html4/-/character-entities-html4-2.1.0.tgz#1f1adb940c971a4b22ba39ddca6b618dc6e56b2b" + integrity sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA== + +character-entities-legacy@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz#76bc83a90738901d7bc223a9e93759fdd560125b" + integrity sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ== + ci-info@^3.2.0: version "3.5.0" resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-3.5.0.tgz#bfac2a29263de4c829d806b1ab478e35091e171f" @@ -1475,6 +1563,11 @@ color-name@~1.1.4: resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2" integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== +comma-separated-tokens@^2.0.0: + version "2.0.3" + resolved "https://registry.yarnpkg.com/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz#4e89c9458acb61bc8fef19f4529973b2392839ee" + integrity sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg== + commander@^10.0.1: version "10.0.1" resolved "https://registry.yarnpkg.com/commander/-/commander-10.0.1.tgz#881ee46b4f77d1c1dccc5823433aa39b022cbe06" @@ -1558,11 +1651,23 @@ define-properties@^1.1.3, define-properties@^1.1.4: has-property-descriptors "^1.0.0" object-keys "^1.1.1" +dequal@^2.0.0: + version "2.0.3" + resolved "https://registry.yarnpkg.com/dequal/-/dequal-2.0.3.tgz#2644214f1997d39ed0ee0ece72335490a7ac67be" + integrity sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA== + detect-newline@^3.0.0: version "3.1.0" resolved "https://registry.yarnpkg.com/detect-newline/-/detect-newline-3.1.0.tgz#576f5dfc63ae1a192ff192d8ad3af6308991b651" integrity sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA== +devlop@^1.0.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/devlop/-/devlop-1.1.0.tgz#4db7c2ca4dc6e0e834c30be70c94bbc976dc7018" + integrity sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA== + dependencies: + dequal "^2.0.0" + diff-sequences@^29.4.3: version "29.4.3" resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-29.4.3.tgz#9314bc1fabe09267ffeca9cbafc457d8499a13f2" @@ -1609,6 +1714,11 @@ emoji-regex@^8.0.0: resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37" integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== +entities@^4.4.0: + version "4.5.0" + resolved "https://registry.yarnpkg.com/entities/-/entities-4.5.0.tgz#5d268ea5e7113ec74c4d033b79ea5a35a488fb48" + integrity sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw== + error-ex@^1.3.1: version "1.3.2" resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf" @@ -2271,11 +2381,40 @@ has@^1.0.3: dependencies: function-bind "^1.1.1" +hast-util-to-html@^9.0.3: + version "9.0.3" + resolved "https://registry.yarnpkg.com/hast-util-to-html/-/hast-util-to-html-9.0.3.tgz#a9999a0ba6b4919576a9105129fead85d37f302b" + integrity sha512-M17uBDzMJ9RPCqLMO92gNNUDuBSq10a25SDBI08iCCxmorf4Yy6sYHK57n9WAbRAAaU+DuR4W6GN9K4DFZesYg== + dependencies: + "@types/hast" "^3.0.0" + "@types/unist" "^3.0.0" + ccount "^2.0.0" + comma-separated-tokens "^2.0.0" + hast-util-whitespace "^3.0.0" + html-void-elements "^3.0.0" + mdast-util-to-hast "^13.0.0" + property-information "^6.0.0" + space-separated-tokens "^2.0.0" + stringify-entities "^4.0.0" + zwitch "^2.0.4" + +hast-util-whitespace@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz#7778ed9d3c92dd9e8c5c8f648a49c21fc51cb621" + integrity sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw== + dependencies: + "@types/hast" "^3.0.0" + html-escaper@^2.0.0: version "2.0.2" resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453" integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg== +html-void-elements@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/html-void-elements/-/html-void-elements-3.0.0.tgz#fc9dbd84af9e747249034d4d62602def6517f1d7" + integrity sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg== + human-signals@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0" @@ -3027,6 +3166,13 @@ lines-and-columns@^1.1.6: resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632" integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg== +linkify-it@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/linkify-it/-/linkify-it-5.0.0.tgz#9ef238bfa6dc70bd8e7f9572b52d369af569b421" + integrity sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ== + dependencies: + uc.micro "^2.0.0" + locate-path@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0" @@ -3070,6 +3216,11 @@ lru-cache@^6.0.0: dependencies: yallist "^4.0.0" +lunr@^2.3.9: + version "2.3.9" + resolved "https://registry.yarnpkg.com/lunr/-/lunr-2.3.9.tgz#18b123142832337dd6e964df1a5a7707b25d35e1" + integrity sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow== + lzutf8@0.6.3: version "0.6.3" resolved "https://registry.yarnpkg.com/lzutf8/-/lzutf8-0.6.3.tgz#37a2ebe80922a8405f1e3f24c6c2b74c3e430981" @@ -3096,6 +3247,38 @@ makeerror@1.0.12: dependencies: tmpl "1.0.5" +markdown-it@^14.1.0: + version "14.1.0" + resolved "https://registry.yarnpkg.com/markdown-it/-/markdown-it-14.1.0.tgz#3c3c5992883c633db4714ccb4d7b5935d98b7d45" + integrity sha512-a54IwgWPaeBCAAsv13YgmALOF1elABB08FxO9i+r4VFk5Vl4pKokRPeX8u5TCgSsPi6ec1otfLjdOpVcgbpshg== + dependencies: + argparse "^2.0.1" + entities "^4.4.0" + linkify-it "^5.0.0" + mdurl "^2.0.0" + punycode.js "^2.3.1" + uc.micro "^2.1.0" + +mdast-util-to-hast@^13.0.0: + version "13.2.0" + resolved "https://registry.yarnpkg.com/mdast-util-to-hast/-/mdast-util-to-hast-13.2.0.tgz#5ca58e5b921cc0a3ded1bc02eed79a4fe4fe41f4" + integrity sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA== + dependencies: + "@types/hast" "^3.0.0" + "@types/mdast" "^4.0.0" + "@ungap/structured-clone" "^1.0.0" + devlop "^1.0.0" + micromark-util-sanitize-uri "^2.0.0" + trim-lines "^3.0.0" + unist-util-position "^5.0.0" + unist-util-visit "^5.0.0" + vfile "^6.0.0" + +mdurl@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/mdurl/-/mdurl-2.0.0.tgz#80676ec0433025dd3e17ee983d0fe8de5a2237e0" + integrity sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w== + merge-stream@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60" @@ -3106,6 +3289,38 @@ merge2@^1.3.0, merge2@^1.4.1: resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae" integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg== +micromark-util-character@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/micromark-util-character/-/micromark-util-character-2.1.0.tgz#31320ace16b4644316f6bf057531689c71e2aee1" + integrity sha512-KvOVV+X1yLBfs9dCBSopq/+G1PcgT3lAK07mC4BzXi5E7ahzMAF8oIupDDJ6mievI6F+lAATkbQQlQixJfT3aQ== + dependencies: + micromark-util-symbol "^2.0.0" + micromark-util-types "^2.0.0" + +micromark-util-encode@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-encode/-/micromark-util-encode-2.0.0.tgz#0921ac7953dc3f1fd281e3d1932decfdb9382ab1" + integrity sha512-pS+ROfCXAGLWCOc8egcBvT0kf27GoWMqtdarNfDcjb6YLuV5cM3ioG45Ys2qOVqeqSbjaKg72vU+Wby3eddPsA== + +micromark-util-sanitize-uri@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.0.tgz#ec8fbf0258e9e6d8f13d9e4770f9be64342673de" + integrity sha512-WhYv5UEcZrbAtlsnPuChHUAsu/iBPOVaEVsntLBIdpibO0ddy8OzavZz3iL2xVvBZOpolujSliP65Kq0/7KIYw== + dependencies: + micromark-util-character "^2.0.0" + micromark-util-encode "^2.0.0" + micromark-util-symbol "^2.0.0" + +micromark-util-symbol@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-symbol/-/micromark-util-symbol-2.0.0.tgz#12225c8f95edf8b17254e47080ce0862d5db8044" + integrity sha512-8JZt9ElZ5kyTnO94muPxIGS8oyElRJaiJO8EzV6ZSyGQ1Is8xwl4Q45qU5UOg+bGH4AikWziz0iN4sFLWs8PGw== + +micromark-util-types@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/micromark-util-types/-/micromark-util-types-2.0.0.tgz#63b4b7ffeb35d3ecf50d1ca20e68fc7caa36d95e" + integrity sha512-oNh6S2WMHWRZrmutsRmDDfkzKtxF+bc2VxLC9dvtrDIRFln627VsFP6fLMgTryGDljgLPjkrzQSDcPrjPyDJ5w== + micromatch@^4.0.4: version "4.0.5" resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6" @@ -3126,6 +3341,13 @@ minimatch@^3.0.4, minimatch@^3.0.5, minimatch@^3.1.1, minimatch@^3.1.2: dependencies: brace-expansion "^1.1.7" +minimatch@^9.0.5: + version "9.0.5" + resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-9.0.5.tgz#d74f9dd6b57d83d8e98cfb82133b03978bc929e5" + integrity sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow== + dependencies: + brace-expansion "^2.0.1" + minimist@^1.2.0, minimist@^1.2.6: version "1.2.7" resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.7.tgz#daa1c4d91f507390437c6a8bc01078e7000c4d18" @@ -3235,6 +3457,13 @@ onetime@^5.1.2: dependencies: mimic-fn "^2.1.0" +oniguruma-to-js@0.4.3: + version "0.4.3" + resolved "https://registry.yarnpkg.com/oniguruma-to-js/-/oniguruma-to-js-0.4.3.tgz#8d899714c21f5c7d59a3c0008ca50e848086d740" + integrity sha512-X0jWUcAlxORhOqqBREgPMgnshB7ZGYszBNspP+tS9hPD3l13CdaXcHbgImoHUHlrvGx/7AvFEkTRhAGYh+jzjQ== + dependencies: + regex "^4.3.2" + optionator@^0.9.1: version "0.9.1" resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.1.tgz#4f236a6373dae0566a6d43e1326674f50c291499" @@ -3376,6 +3605,16 @@ prompts@^2.0.1: kleur "^3.0.3" sisteransi "^1.0.5" +property-information@^6.0.0: + version "6.5.0" + resolved "https://registry.yarnpkg.com/property-information/-/property-information-6.5.0.tgz#6212fbb52ba757e92ef4fb9d657563b933b7ffec" + integrity sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig== + +punycode.js@^2.3.1: + version "2.3.1" + resolved "https://registry.yarnpkg.com/punycode.js/-/punycode.js-2.3.1.tgz#6b53e56ad75588234e79f4affa90972c7dd8cdb7" + integrity sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA== + punycode@^2.1.0: version "2.1.1" resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec" @@ -3423,6 +3662,11 @@ readable-stream@^4.0.0: events "^3.3.0" process "^0.11.10" +regex@^4.3.2: + version "4.4.0" + resolved "https://registry.yarnpkg.com/regex/-/regex-4.4.0.tgz#cb731e2819f230fad69089e1bd854fef7569e90a" + integrity sha512-uCUSuobNVeqUupowbdZub6ggI5/JZkYyJdDogddJr60L764oxC2pMZov1fQ3wM9bdyzUILDG+Sqx6NAKAz9rKQ== + regexp.prototype.flags@^1.4.3: version "1.4.3" resolved "https://registry.yarnpkg.com/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz#87cab30f80f66660181a3bb7bf5981a872b367ac" @@ -3548,6 +3792,18 @@ shebang-regex@^3.0.0: resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172" integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== +shiki@^1.16.2: + version "1.22.2" + resolved "https://registry.yarnpkg.com/shiki/-/shiki-1.22.2.tgz#ed109a3d0850504ad5a1edf8496470a2121c5b7b" + integrity sha512-3IZau0NdGKXhH2bBlUk4w1IHNxPh6A5B2sUpyY+8utLu2j/h1QpFkAaUA1bAMxOWWGtTWcAh531vnS4NJKS/lA== + dependencies: + "@shikijs/core" "1.22.2" + "@shikijs/engine-javascript" "1.22.2" + "@shikijs/engine-oniguruma" "1.22.2" + "@shikijs/types" "1.22.2" + "@shikijs/vscode-textmate" "^9.3.0" + "@types/hast" "^3.0.4" + side-channel@^1.0.4: version "1.0.4" resolved "https://registry.yarnpkg.com/side-channel/-/side-channel-1.0.4.tgz#efce5c8fdc104ee751b25c58d4290011fa5ea2cf" @@ -3585,6 +3841,11 @@ source-map@^0.6.0, source-map@^0.6.1: resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263" integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== +space-separated-tokens@^2.0.0: + version "2.0.2" + resolved "https://registry.yarnpkg.com/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz#1ecd9d2350a3844572c3f4a312bceb018348859f" + integrity sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q== + sprintf-js@~1.0.2: version "1.0.3" resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c" @@ -3664,6 +3925,14 @@ string.prototype.trimstart@^1.0.6: define-properties "^1.1.4" es-abstract "^1.20.4" +stringify-entities@^4.0.0: + version "4.0.4" + resolved "https://registry.yarnpkg.com/stringify-entities/-/stringify-entities-4.0.4.tgz#b3b79ef5f277cc4ac73caeb0236c5ba939b3a4f3" + integrity sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg== + dependencies: + character-entities-html4 "^2.0.0" + character-entities-legacy "^3.0.0" + strip-ansi@^6.0.0, strip-ansi@^6.0.1: version "6.0.1" resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9" @@ -3748,6 +4017,11 @@ to-regex-range@^5.0.1: dependencies: is-number "^7.0.0" +trim-lines@^3.0.0: + version "3.0.1" + resolved "https://registry.yarnpkg.com/trim-lines/-/trim-lines-3.0.1.tgz#d802e332a07df861c48802c04321017b1bd87338" + integrity sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg== + ts-jest@^29.1.0: version "29.1.0" resolved "https://registry.yarnpkg.com/ts-jest/-/ts-jest-29.1.0.tgz#4a9db4104a49b76d2b368ea775b6c9535c603891" @@ -3834,11 +4108,32 @@ typed-array-length@^1.0.4: for-each "^0.3.3" is-typed-array "^1.1.9" +typedoc-github-theme@^0.1.2: + version "0.1.2" + resolved "https://registry.yarnpkg.com/typedoc-github-theme/-/typedoc-github-theme-0.1.2.tgz#54bcaa05a22ec864d1a996c3c460d895a8b10a8b" + integrity sha512-GFwQeq+z4FMtA9u2+wBx/UvzaX6t3xueigv6Jrt1G8JQLLyYuFfWwE3ESuKzpLfDu1+29GK4n70GbIqFRG+gaw== + +typedoc@^0.26.11: + version "0.26.11" + resolved "https://registry.yarnpkg.com/typedoc/-/typedoc-0.26.11.tgz#124b43a5637b7f3237b8c721691b44738c5c9dc9" + integrity sha512-sFEgRRtrcDl2FxVP58Ze++ZK2UQAEvtvvH8rRlig1Ja3o7dDaMHmaBfvJmdGnNEFaLTpQsN8dpvZaTqJSu/Ugw== + dependencies: + lunr "^2.3.9" + markdown-it "^14.1.0" + minimatch "^9.0.5" + shiki "^1.16.2" + yaml "^2.5.1" + typescript@5.3.3: version "5.3.3" resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.3.3.tgz#b3ce6ba258e72e6305ba66f5c9b452aaee3ffe37" integrity sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw== +uc.micro@^2.0.0, uc.micro@^2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/uc.micro/-/uc.micro-2.1.0.tgz#f8d3f7d0ec4c3dea35a7e3c8efa4cb8b45c9e7ee" + integrity sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A== + unbox-primitive@^1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/unbox-primitive/-/unbox-primitive-1.0.2.tgz#29032021057d5e6cdbd08c5129c226dff8ed6f9e" @@ -3856,6 +4151,44 @@ undici@^5.2.0: dependencies: busboy "^1.6.0" +unist-util-is@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/unist-util-is/-/unist-util-is-6.0.0.tgz#b775956486aff107a9ded971d996c173374be424" + integrity sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw== + dependencies: + "@types/unist" "^3.0.0" + +unist-util-position@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/unist-util-position/-/unist-util-position-5.0.0.tgz#678f20ab5ca1207a97d7ea8a388373c9cf896be4" + integrity sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA== + dependencies: + "@types/unist" "^3.0.0" + +unist-util-stringify-position@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz#449c6e21a880e0855bf5aabadeb3a740314abac2" + integrity sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ== + dependencies: + "@types/unist" "^3.0.0" + +unist-util-visit-parents@^6.0.0: + version "6.0.1" + resolved "https://registry.yarnpkg.com/unist-util-visit-parents/-/unist-util-visit-parents-6.0.1.tgz#4d5f85755c3b8f0dc69e21eca5d6d82d22162815" + integrity sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw== + dependencies: + "@types/unist" "^3.0.0" + unist-util-is "^6.0.0" + +unist-util-visit@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/unist-util-visit/-/unist-util-visit-5.0.0.tgz#a7de1f31f72ffd3519ea71814cccf5fd6a9217d6" + integrity sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg== + dependencies: + "@types/unist" "^3.0.0" + unist-util-is "^6.0.0" + unist-util-visit-parents "^6.0.0" + update-browserslist-db@^1.0.9: version "1.0.10" resolved "https://registry.yarnpkg.com/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz#0f54b876545726f17d00cd9a2561e6dade943ff3" @@ -3885,6 +4218,22 @@ v8-to-istanbul@^9.0.1: "@types/istanbul-lib-coverage" "^2.0.1" convert-source-map "^1.6.0" +vfile-message@^4.0.0: + version "4.0.2" + resolved "https://registry.yarnpkg.com/vfile-message/-/vfile-message-4.0.2.tgz#c883c9f677c72c166362fd635f21fc165a7d1181" + integrity sha512-jRDZ1IMLttGj41KcZvlrYAaI3CfqpLpfpf+Mfig13viT6NKvRzWZ+lXz0Y5D60w6uJIBAOGq9mSHf0gktF0duw== + dependencies: + "@types/unist" "^3.0.0" + unist-util-stringify-position "^4.0.0" + +vfile@^6.0.0: + version "6.0.3" + resolved "https://registry.yarnpkg.com/vfile/-/vfile-6.0.3.tgz#3652ab1c496531852bf55a6bac57af981ebc38ab" + integrity sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q== + dependencies: + "@types/unist" "^3.0.0" + vfile-message "^4.0.0" + walker@^1.0.8: version "1.0.8" resolved "https://registry.yarnpkg.com/walker/-/walker-1.0.8.tgz#bd498db477afe573dc04185f011d3ab8a8d7653f" @@ -3986,6 +4335,11 @@ yallist@^4.0.0: resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72" integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A== +yaml@^2.5.1: + version "2.6.0" + resolved "https://registry.yarnpkg.com/yaml/-/yaml-2.6.0.tgz#14059ad9d0b1680d0f04d3a60fe00f3a857303c3" + integrity sha512-a6ae//JvKDEra2kdi1qzCyrJW/WZCgFi8ydDV+eXExl95t+5R+ijnqHJbz9tmMh8FUjx3iv2fCQ4dclAQlO2UQ== + yargs-parser@^21.0.1, yargs-parser@^21.1.1: version "21.1.1" resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35" @@ -4013,3 +4367,8 @@ yocto-queue@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b" integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q== + +zwitch@^2.0.4: + version "2.0.4" + resolved "https://registry.yarnpkg.com/zwitch/-/zwitch-2.0.4.tgz#c827d4b0acb76fc3e685a4c6ec2902d51070e9d7" + integrity sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==