@verii/endpoints-organizations-registrar 1.0.0-pre.1752076816

package/src/controllers/resolve-did/schemas/did-doc.schema.json

@@ -0,0 +1,155 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "did-doc",
+  "title": "did-doc",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "@context": {
+      "title": "@context",
+      "description": "https://w3c.github.io/did-core-registries/#context",
+      "oneOf": [
+        {
+          "type": "string",
+          "const": "https://www.w3.org/ns/did/v1"
+        },
+        {
+          "type": "array",
+          "additionalItems": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "object"
+              }
+            ]
+          },
+          "prefixItems": [
+            {
+              "type": "string",
+              "const": "https://www.w3.org/ns/did/v1"
+            }
+          ]
+        },
+        {
+          "type": "object"
+        }
+      ]
+    },
+    "id": {
+      "title": "DID",
+      "description": "https://w3c.github.io/did-core-registries/#id",
+      "type": "string",
+      "pattern": "^did:[a-z0-9]+:[A-Za-z0-9._:?=&%;-]+$",
+      "example": [
+        "did:key:z6MksQ35B5bwZDQq4QKuhQW2Sv6dcqwg4PqcSFf67pdgrtjB"
+      ]
+    },
+    "controller": {
+      "title": "DID Controller",
+      "description": "https://w3c.github.io/did-core-registries/#controller",
+      "example": [
+        "did:key:z6MksQ35B5bwZDQq4QKuhQW2Sv6dcqwg4PqcSFf67pdgrtjB"
+      ],
+      "oneOf": [
+        {
+          "type": "string",
+          "pattern": "^did:[a-z0-9]+:[A-Za-z0-9._:?=&%;-]+$"
+        },
+        {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "pattern": "^did:[a-z0-9]+:[A-Za-z0-9._:?=&%;-]+$"
+          }
+        }
+      ]
+    },
+    "publicKey": {
+      "title": "Public Key",
+      "deprecated": true,
+      "description": "https://w3c.github.io/did-core-registries/#publicKey",
+      "type": "array",
+      "items": {
+        "$ref": "public-key#"
+      }
+    },
+    "verificationMethod": {
+      "title": "Verification Methods of the did doc",
+      "description": "https://w3c.github.io/did-spec-registries/#verificationmethod",
+      "type": "array",
+      "items": {
+        "$ref": "public-key#"
+      }
+    },
+    "authentication": {
+      "title": "Authentication",
+      "description": "https://w3c.github.io/did-core-registries/#authentication",
+      "type": "array",
+      "items": {
+        "oneOf": [
+          {
+            "type": "string"
+          },
+          {
+            "$ref": "public-key#"
+          }
+        ]
+      }
+    },
+    "assertionMethod": {
+      "title": "Assertion Method",
+      "description": "https://w3c.github.io/did-core-registries/#assertionMethod",
+      "type": "array",
+      "items": {
+        "oneOf": [
+          {
+            "type": "string"
+          },
+          {
+            "$ref": "public-key#"
+          }
+        ]
+      }
+    },
+    "alsoKnownAs": {
+      "title": "Also Known As",
+      "description": "https://www.w3.org/TR/did-core/#also-known-as",
+      "type": "array",
+      "items": {
+        "type": "string",
+        "format": "uri"
+      }
+    },
+    "service": {
+      "title": "Service",
+      "description": "https://w3c.github.io/did-core-registries/#service",
+      "type": "array",
+      "items": {
+        "$ref": "did-service#"
+      }
+    },
+    "created": {
+      "title": "Created",
+      "description": "https://w3c.github.io/did-core-registries/#created",
+      "type": "string",
+      "format": "date-time"
+    },
+    "updated": {
+      "title": "Updated",
+      "description": "https://w3c.github.io/did-core-registries/#updated",
+      "type": "string",
+      "format": "date-time"
+    },
+    "proof": {
+      "title": "Proof",
+      "description": "https://w3c.github.io/did-core-registries/#proof",
+      "type": "string",
+      "$ref": "did-proof#"
+    }
+  },
+  "required": [
+    "id"
+  ]
+}

package/src/controllers/resolve-did/schemas/did-proof.schema.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "did-proof",
+  "title": "did-proof",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "created": {
+      "title": "Created",
+      "description": "https://w3c.github.io/did-core-registries/#created",
+      "type": "string",
+      "format": "date-time"
+    },
+    "jws": {
+      "title": "JWS",
+      "description": "https://w3c.github.io/did-core-registries/#jws",
+      "type": "string"
+    },
+    "proofPurpose": {
+      "title": "Proof Purpose",
+      "description": "https://w3c.github.io/did-core-registries/#proof-purpose",
+      "type": "string",
+      "enum": ["assertionMethod", "authentication"]
+    },
+    "type": {
+      "title": "Type of Proof supplied",
+      "description": "https://w3c.github.io/did-core-registries/#type",
+      "type": "string",
+      "enum": ["EcdsaSecp256k1Signature2019", "Ed25519Signature2020"]
+    },
+    "verificationMethod": {
+      "title": "Verification Method",
+      "description": "https://w3c.github.io/did-core-registries/#verification-method",
+      "oneOf": [
+        {
+          "type": "string"
+        },
+        {
+          "$ref": "public-key#"
+        }
+      ]
+    }
+  }
+}

package/src/controllers/resolve-did/schemas/index.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2024 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+const didDocSchema = require('./did-doc.schema.json');
+const didProofSchema = require('./did-proof.schema.json');
+const publicKeySchema = require('./public-key.schema.json');
+
+module.exports = {
+  didDocSchema,
+  publicKeySchema,
+  didProofSchema,
+};

package/src/controllers/resolve-did/schemas/public-key.schema.json

@@ -0,0 +1,173 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "public-key",
+  "title": "public-key",
+  "description": "A public key is a verification method. Public keys are used for digital signatures, encryption and other cryptographic operations, which in turn are the basis for purposes such as authentication.",
+  "oneOf": [
+    {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "id": {
+          "title": "Public Key ID",
+          "type": "string",
+          "example": [
+            "did:example:123#primary"
+          ]
+        },
+        "type": {
+          "title": "Public Key Type",
+          "type": "string",
+          "enum": [
+            "JsonWebKey2020",
+            "EcdsaSecp256k1VerificationKey2019",
+            "X25519KeyAgreementKey2019",
+            "Ed25519VerificationKey2018"
+          ],
+          "example": [
+            "JsonWebKey2020"
+          ]
+        },
+        "controller": {
+          "title": "Controller",
+          "description": "https://w3c.github.io/did-core-registries/#controller",
+          "type": "string",
+          "example": [
+            "did:example:123"
+          ]
+        },
+        "publicKeyJwk": {
+          "title": "Public Key JWK",
+          "description": "https://w3c.github.io/did-spec-registries/#publickeyjwk",
+          "type": "object",
+          "properties": {
+            "crv": {
+              "type": "string"
+            },
+            "kid": {
+              "type": "string"
+            },
+            "kty": {
+              "type": "string"
+            },
+            "x": {
+              "type": "string"
+            },
+            "y": {
+              "type": "string"
+            }
+          },
+          "example": [
+            {
+              "crv": "secp256k1",
+              "kid": "JUvpllMEYUZ2joO59UNui_XYDqxVqiFLLAJ8klWuPBw",
+              "kty": "EC",
+              "x": "dWCvM4fTdeM0KmloF57zxtBPXTOythHPMm1HCLrdd3A",
+              "y": "36uMVGM7hnw-N6GnjFcihWE3SkrhMLzzLCdPMXPEXlA"
+            }
+          ]
+        }
+      },
+      "required": [
+        "id",
+        "type",
+        "controller",
+        "publicKeyJwk"
+      ]
+    },
+    {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "id": {
+          "title": "Public Key ID",
+          "type": "string",
+          "example": [
+            "did:example:123#primary"
+          ]
+        },
+        "type": {
+          "title": "Public Key Type",
+          "type": "string",
+          "enum": [
+            "EcdsaSecp256k1VerificationKey2019",
+            "X25519KeyAgreementKey2019",
+            "Ed25519VerificationKey2018"
+          ],
+          "example": [
+            "EcdsaSecp256k1VerificationKey2019"
+          ]
+        },
+        "controller": {
+          "title": "Controller",
+          "description": "https://w3c.github.io/did-core-registries/#controller",
+          "type": "string",
+          "example": [
+            "did:example:123"
+          ]
+        },
+        "publicKeyMultibase": {
+          "title": "Public Key in multibase format",
+          "description": "https://w3c.github.io/did-spec-registries/#multibase",
+          "type": "string",
+          "example": [
+            "CaSHXEvLKS6SfN9aBfkVGBpp15jSnaHazqHgLHp8KZ3Y"
+          ]
+        }
+      },
+      "required": [
+        "id",
+        "type",
+        "controller",
+        "publicKeyMultibase"
+      ]
+    },
+    {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "id": {
+          "title": "Public Key ID",
+          "type": "string",
+          "example": [
+            "did:example:123#primary"
+          ]
+        },
+        "type": {
+          "title": "Public Key Type",
+          "type": "string",
+          "enum": [
+            "EcdsaSecp256k1VerificationKey2019",
+            "X25519KeyAgreementKey2019",
+            "Ed25519VerificationKey2018"
+          ],
+          "example": [
+            "EcdsaSecp256k1VerificationKey2019"
+          ]
+        },
+        "controller": {
+          "title": "Controller",
+          "description": "https://w3c.github.io/did-core-registries/#controller",
+          "type": "string",
+          "example": [
+            "did:example:123"
+          ]
+        },
+        "publicKeyBase58": {
+          "title": "Public Key Base58",
+          "description": "https://w3c.github.io/did-spec-registries/#publickeybase58",
+          "type": "string",
+          "example": [
+            "CaSHXEvLKS6SfN9aBfkVGBpp15jSnaHazqHgLHp8KZ3Y"
+          ]
+        }
+      },
+      "required": [
+        "id",
+        "type",
+        "controller",
+        "publicKeyBase58"
+      ]
+    }
+  ]
+}

package/src/controllers/resolve-kid/controller.js

@@ -0,0 +1,76 @@
+const { flow, split, first } = require('lodash/fp');
+const { default: bs58 } = require('bs58');
+const newError = require('http-errors');
+
+const { extractVerificationKey } = require('@verii/did-doc');
+const { publicKeyHexToPem } = require('@verii/crypto');
+const { jwkFromSecp256k1Key } = require('@verii/jwt');
+const { resolveDid } = require('../resolve-did/resolve-did');
+const publicKeyFormats = require('./public-key-formats');
+
+const resolversController = async (fastify) => {
+  const publicKeyEncoders = {
+    [publicKeyFormats.PEM]: (publicKey) => publicKeyHexToPem(publicKey),
+    [publicKeyFormats.BASE58]: (publicKey) =>
+      bs58.encode(Buffer.from(publicKey, 'hex')),
+    [publicKeyFormats.HEX]: (publicKey) => publicKey,
+    [publicKeyFormats.JWK]: (publicKey) =>
+      JSON.stringify(jwkFromSecp256k1Key(publicKey, false)),
+  };
+
+  fastify.get(
+    '/:kid',
+    {
+      schema: fastify.autoSchema({
+        tags: ['registrar_organizations'],
+        params: {
+          type: 'object',
+          properties: {
+            kid: {
+              type: 'string',
+            },
+          },
+        },
+        querystring: {
+          type: 'object',
+          properties: {
+            format: {
+              type: 'string',
+              enum: [
+                publicKeyFormats.PEM,
+                publicKeyFormats.BASE58,
+                publicKeyFormats.HEX,
+                publicKeyFormats.JWK,
+              ],
+              default: publicKeyFormats.PEM,
+            },
+          },
+        },
+        response: {
+          200: { type: 'string' },
+          404: { type: 'string' },
+        },
+      }),
+    },
+    async (req) => {
+      const {
+        params: { kid },
+        query: { format },
+      } = req;
+      const did = flow(split('#'), first)(kid);
+      const didDoc = await resolveDid(did, req);
+
+      const publicKey = extractVerificationKey(didDoc, kid);
+      if (!publicKey) {
+        throw newError.NotFound(`Public key was not found in document ${did}`, {
+          kid,
+          didDoc,
+        });
+      }
+
+      return publicKeyEncoders[format](publicKey);
+    }
+  );
+};
+
+module.exports = resolversController;

package/src/controllers/resolve-kid/public-key-formats.js

@@ -0,0 +1,8 @@
+const PublicKeyFormats = Object.freeze({
+  PEM: 'pem',
+  BASE58: 'base58',
+  HEX: 'hex',
+  JWK: 'jwk',
+});
+
+module.exports = PublicKeyFormats;

package/src/controllers/service-types/controller.js

@@ -0,0 +1,81 @@
+const {
+  ServiceTypes,
+  ServiceTypeToCategoryMap,
+} = require('@verii/organizations-registry');
+const { map, includes } = require('lodash/fp');
+
+const CredentialGroupToServiceTypeMap = {
+  [ServiceTypes.IdentityIssuerType]: undefined,
+  [ServiceTypes.InspectionType]: undefined,
+  [ServiceTypes.NotaryIssuerType]: 'Contact',
+  [ServiceTypes.HolderAppProviderType]: undefined,
+  [ServiceTypes.NodeOperatorType]: undefined,
+  [ServiceTypes.CredentialAgentOperatorType]: undefined,
+  [ServiceTypes.CareerIssuerType]: 'Career',
+  [ServiceTypes.IdDocumentIssuerType]: 'IdDocument',
+  [ServiceTypes.NotaryIdDocumentIssuerType]: 'IdDocument',
+  [ServiceTypes.ContactIssuerType]: 'Contact',
+  [ServiceTypes.NotaryContactIssuerType]: 'Contact',
+};
+
+const isNotary = (serviceType) =>
+  includes(serviceType, [
+    ServiceTypes.NotaryContactIssuerType,
+    ServiceTypes.NotaryIdDocumentIssuerType,
+    ServiceTypes.NotaryIssuerType,
+  ]);
+
+const serviceTypesController = async (fastify) => {
+  fastify.get(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              serviceTypes: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  properties: {
+                    serviceType: {
+                      type: 'string',
+                    },
+                    serviceCategory: {
+                      type: 'string',
+                    },
+                    notary: {
+                      type: 'boolean',
+                    },
+                    credentialGroup: {
+                      type: 'string',
+                      enum: ['Career', 'IdDocument', 'Contact'],
+                    },
+                  },
+                  required: ['serviceType', 'serviceCategory'],
+                },
+              },
+            },
+          },
+        },
+      }),
+    },
+    async () => {
+      const serviceTypes = map(
+        (serviceType) => ({
+          serviceType,
+          serviceCategory: ServiceTypeToCategoryMap[serviceType],
+          notary: isNotary(serviceType),
+          credentialGroup: CredentialGroupToServiceTypeMap[serviceType],
+        }),
+        ServiceTypes
+      );
+      return {
+        serviceTypes,
+      };
+    }
+  );
+};
+
+module.exports = serviceTypesController;

package/src/controllers/setup_image_upload/controller.js

@@ -0,0 +1,99 @@
+const { initS3Client } = require('@verii/aws-clients');
+const { values, isEmpty } = require('lodash/fp');
+const newError = require('http-errors');
+const { ExtensionTypes, getMimeType } = require('@verii/image-processing');
+const { nanoid } = require('nanoid');
+const {
+  RegistrarScopes,
+  ImageState,
+  imageMetadataSchema,
+} = require('../../entities');
+
+const controller = async (fastify) => {
+  const { mediaS3Bucket, mediaPutAccessKey, mediaPutAccessKeyId } =
+    fastify.config;
+
+  const s3Client = initS3Client({
+    ...fastify.config,
+    s3Bucket: mediaS3Bucket,
+    secretAccessKey: mediaPutAccessKey,
+    accessKeyId: mediaPutAccessKeyId,
+  });
+
+  fastify.post(
+    '/',
+    {
+      onRequest: fastify.verifyAccessToken([
+        RegistrarScopes.AdminOrganizations,
+        RegistrarScopes.WriteOrganizations,
+      ]),
+      schema: fastify.autoSchema({
+        security: [
+          {
+            RegistrarOAuth2: [
+              RegistrarScopes.WriteOrganizations,
+              RegistrarScopes.AdminOrganizations,
+            ],
+          },
+        ],
+        body: {
+          type: 'object',
+          properties: {
+            extension: {
+              type: 'string',
+              enum: values(ExtensionTypes),
+            },
+          },
+          required: ['extension'],
+        },
+        response: {
+          200: imageMetadataSchema,
+        },
+      }),
+    },
+    async (req) => {
+      const {
+        user,
+        body,
+        repos,
+        config: { mediaUrl },
+      } = req;
+
+      if (isEmpty(user?.sub)) {
+        throw newError(401, 'User not found', {
+          errorCode: 'user_not_found',
+        });
+      }
+
+      const mime = getMimeType(body.extension);
+      const key = generateLogoName({
+        format: body.extension,
+        height: 400,
+        width: 400,
+      });
+      const url = await s3Client.getSignedUrl({
+        key: `temporary/${key}`,
+        contentType: mime,
+      });
+      const publicUrl = `${mediaUrl}/${key}`;
+      const imageMetadata = await repos.images.insert({
+        key,
+        url: publicUrl,
+        uploadUrl: url,
+        userId: user.sub,
+        uploadSucceeded: false,
+        state: ImageState.PENDING_UPLOAD,
+      });
+      return {
+        imageMetadata,
+      };
+    }
+  );
+};
+
+const generateLogoName = ({ format, height, width }) => {
+  const newImageFormat = format === 'svg' ? 'png' : format;
+  return `${height}x${width}-${nanoid()}.${newImageFormat}`;
+};
+
+module.exports = controller;