gdc-common-utils-ts 2.5.6 → 2.5.8

package/dist/constants/organization-application.d.ts

@@ -13,12 +13,12 @@ export declare function isOrganizationRegistrationReviewAction(value: unknown):
 export declare const OrganizationRegistrationErrors: Readonly<{
     readonly InvalidReviewAction: "invalid_review_action";
     readonly ApplicationNotReviewable: "application_not_reviewable";
-    readonly AuthorizationCredentialRequired: "organization_authorization_credential_required";
+    readonly AdmissionCredentialRequired: "organization_test_network_credential_required";
     readonly ReviewFailed: "review_failed";
     readonly InvalidOrganization: "invalid_organization";
     readonly ApplicationFailed: "application_failed";
 }>;
-/** Default and accepted authorization validity window for registration evidence. */
+/** Default and accepted Test Network admission validity window. */
 export declare const OrganizationRegistrationValidity: Readonly<{
     readonly DefaultDays: 180;
     readonly MinimumDays: 1;

package/dist/constants/organization-application.js

@@ -15,12 +15,12 @@ export function isOrganizationRegistrationReviewAction(value) {
 export const OrganizationRegistrationErrors = Object.freeze({
     InvalidReviewAction: 'invalid_review_action',
     ApplicationNotReviewable: 'application_not_reviewable',
-    AuthorizationCredentialRequired: 'organization_authorization_credential_required',
+    AdmissionCredentialRequired: 'organization_test_network_credential_required',
     ReviewFailed: 'review_failed',
     InvalidOrganization: 'invalid_organization',
     ApplicationFailed: 'application_failed',
 });
-/** Default and accepted authorization validity window for registration evidence. */
+/** Default and accepted Test Network admission validity window. */
 export const OrganizationRegistrationValidity = Object.freeze({
     DefaultDays: 180,
     MinimumDays: 1,

package/dist/utils/legal-organization-verification-transaction.d.ts

@@ -80,8 +80,8 @@ export type LegalOrganizationVerificationTransactionInput = Readonly<{
      */
     legalRepresentativePayload?: LegalOrganizationVerificationRepresentativePayload;
     verification?: LegalOrganizationVerificationRouting;
-    /** Out-of-band host authorization used only by the Test Network path. */
-    authorizationCredential?: VerifiableCredentialV2;
+    /** Reviewer-issued admission credential used only by the Test Network path. */
+    organizationTestNetworkCredential?: VerifiableCredentialV2;
     /** Three reviewer-issued domain VCs accepted only with Test Network authorization. */
     testNetworkCredentials?: readonly VerifiableCredentialV2[];
     attachments?: unknown[];
@@ -105,7 +105,7 @@ export type LegalOrganizationVerificationTransactionEntry = Readonly<{
         /** @deprecated Legacy ICA wire alias accepted only while migrating old callers. */
         legalRepresentative?: LegalOrganizationVerificationRepresentativePayload;
         verification?: LegalOrganizationVerificationRouting;
-        authorizationCredential?: VerifiableCredentialV2;
+        organizationTestNetworkCredential?: VerifiableCredentialV2;
         testNetworkCredentials?: readonly VerifiableCredentialV2[];
         [key: string]: unknown;
     };

package/dist/utils/legal-organization-verification-transaction.js

@@ -61,8 +61,8 @@ export function buildLegalOrganizationVerificationTransactionBundle(input) {
                     verification: {
                         resourceType: normalizeText(input.verification?.resourceType) || 'contract',
                     },
-                    ...(input.authorizationCredential
-                        ? { authorizationCredential: input.authorizationCredential }
+                    ...(input.organizationTestNetworkCredential
+                        ? { organizationTestNetworkCredential: input.organizationTestNetworkCredential }
                         : {}),
                     ...(input.testNetworkCredentials?.length
                         ? { testNetworkCredentials: input.testNetworkCredentials }

package/dist/utils/organization-test-network-credential.d.ts

@@ -1,5 +1,5 @@
 import type { VerifiableCredentialV2 } from '../models/verifiable-credential';
-/** Lifecycle of the one Test Network activation licence delivered to the legal postal address. */
+/** Lifecycle for a separate postal-address verification credential. */
 export declare const PostalActivationLicenseStatuses: Readonly<{
     readonly Issued: "issued";
     readonly Delivered: "delivered";
@@ -48,13 +48,18 @@ export type OrganizationTestNetworkCredentialInput = Readonly<{
     applicationId: string;
     accessPath: 'partner' | 'test-network';
     targetNetwork: 'test-network' | 'network';
-    postalLicense: PostalActivationLicenseBinding;
+    /**
+     * @deprecated Postal-address verification is a separate production-readiness
+     * flow. This compatibility input is ignored and is never embedded in a Test
+     * Network authorization credential.
+     */
+    postalLicense?: PostalActivationLicenseBinding;
     proof?: VerifiableCredentialV2['proof'];
 }>;
 /**
  * Builds the immutable VC that a controller receives out-of-band and attaches
- * to `Organization/_transaction`. The postal code itself never appears in the
- * credential; its confirmed, purpose-bound licence record is referenced.
+ * to `Organization/_transaction`. Postal-address verification is deliberately
+ * outside this credential and may be completed independently before production.
  */
 export declare function buildOrganizationTestNetworkCredential(input: OrganizationTestNetworkCredentialInput): VerifiableCredentialV2;
 /**

package/dist/utils/organization-test-network-credential.js

@@ -1,5 +1,5 @@
 import { ContractCredentialTypes, W3cCredentialContexts, W3cCredentialTypes, } from '../constants/verifiable-credentials.js';
-/** Lifecycle of the one Test Network activation licence delivered to the legal postal address. */
+/** Lifecycle for a separate postal-address verification credential. */
 export const PostalActivationLicenseStatuses = Object.freeze({
     Issued: 'issued',
     Delivered: 'delivered',
@@ -15,23 +15,13 @@ function required(value, name) {
 }
 /**
  * Builds the immutable VC that a controller receives out-of-band and attaches
- * to `Organization/_transaction`. The postal code itself never appears in the
- * credential; its confirmed, purpose-bound licence record is referenced.
+ * to `Organization/_transaction`. Postal-address verification is deliberately
+ * outside this credential and may be completed independently before production.
  */
 export function buildOrganizationTestNetworkCredential(input) {
     const applicationId = required(input.applicationId, 'applicationId');
     const organizationIdentifier = required(input.organizationIdentifier, 'organizationIdentifier');
     const controllerEmail = required(input.controllerEmail, 'controllerEmail').toLowerCase();
-    if (input.postalLicense.status !== PostalActivationLicenseStatuses.Delivered) {
-        throw new Error('Organization registration authorization requires a delivered postal activation licence.');
-    }
-    if (input.postalLicense.applicationId !== applicationId
-        || input.postalLicense.organizationIdentifier !== organizationIdentifier
-        || input.postalLicense.controllerEmail.trim().toLowerCase() !== controllerEmail
-        || input.postalLicense.controllerKeyMaterial !== input.controllerKeyMaterial
-        || input.postalLicense.network !== input.targetNetwork) {
-        throw new Error('Postal activation licence does not match the organization registration application.');
-    }
     return {
         '@context': [W3cCredentialContexts.V2, 'https://schema.org'],
         id: required(input.credentialId, 'credentialId'),
@@ -53,17 +43,6 @@ export function buildOrganizationTestNetworkCredential(input) {
                 email: controllerEmail,
                 hasCredential: { material: required(input.controllerKeyMaterial, 'controllerKeyMaterial') },
             },
-            postalActivationLicense: {
-                id: required(input.postalLicense.licenseId, 'postalLicense.licenseId'),
-                status: input.postalLicense.status,
-                postalAddressHash: required(input.postalLicense.postalAddressHash, 'postalLicense.postalAddressHash'),
-                deliveredAt: required(input.postalLicense.deliveredAt, 'postalLicense.deliveredAt'),
-                protectedCode: {
-                    algorithm: input.postalLicense.protectedCode.algorithm,
-                    salt: required(input.postalLicense.protectedCode.salt, 'postalLicense.protectedCode.salt'),
-                    digest: required(input.postalLicense.protectedCode.digest, 'postalLicense.protectedCode.digest'),
-                },
-            },
         },
         validFrom: required(input.validFrom, 'validFrom'),
         validUntil: required(input.validUntil, 'validUntil'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-common-utils-ts",
-  "version": "2.5.6",
+  "version": "2.5.8",
   "publishConfig": {
     "access": "public"
   },