@cdklabs/cdk-hyperledger-fabric-network 0.0.20

package/lib/identity.js

@@ -0,0 +1,107 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: MIT-0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperledgerFabricIdentity = void 0;
+const path = require("path");
+const cdk = require("aws-cdk-lib");
+const ec2 = require("aws-cdk-lib/aws-ec2");
+const iam = require("aws-cdk-lib/aws-iam");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const logs = require("aws-cdk-lib/aws-logs");
+const customresources = require("aws-cdk-lib/custom-resources");
+const constructs = require("constructs");
+const utilities = require("./utilities");
+/**
+ * Creates custom resources to enroll admin and register user
+ * identities with the CA using the fabric-ca-client SDK.
+ * Admin identity is enrolled by default. User identities are
+ * registered and enrolled, if provided.
+ */
+class HyperledgerFabricIdentity extends constructs.Construct {
+    constructor(scope, id) {
+        super(scope, id);
+        // Collect metadata on the stack
+        const partition = cdk.Stack.of(this).partition;
+        const region = cdk.Stack.of(this).region;
+        // Retrieve the S3 Bucket and key that contains the TLS cert file
+        const tlsBucketData = utilities.getTlsBucket(region);
+        const adminPasswordArn = scope.adminPasswordSecret.secretArn;
+        const adminPrivateKeyArn = scope.adminPrivateKeySecret.secretArn;
+        const adminSignedCertArn = scope.adminSignedCertSecret.secretArn;
+        const caEndpoint = scope.caEndpoint;
+        const client = scope.client;
+        const memberName = scope.memberName;
+        // Role for the custom resource lambda functions
+        const customResourceRole = new iam.Role(this, 'CustomResourceRole', { assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com') });
+        // Policies for the custom resource lambda to enroll and register users
+        customResourceRole.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'));
+        customResourceRole.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaVPCAccessExecutionRole'));
+        customResourceRole.addToPolicy(new iam.PolicyStatement({
+            actions: ['s3:GetObject', 'secretsmanager:CreateSecret', 'secretsmanager:GetSecretValue', 'secretsmanager:PutSecretValue'],
+            resources: [
+                `arn:${partition}:s3:::${tlsBucketData.bucketName}/*`,
+                adminPasswordArn,
+                adminPrivateKeyArn,
+                adminSignedCertArn,
+            ],
+        }));
+        // Lambda function to enroll the admin and import credentials to secrets manager
+        const adminFunction = new lambda.Function(this, 'AdminFunction', {
+            runtime: lambda.Runtime.NODEJS_14_X,
+            handler: 'enroll-admin.handler',
+            code: lambda.Code.fromAsset(path.join(__dirname, '../lambdas/fabric')),
+            environment: {
+                ADMIN_PASSWORD_ARN: adminPasswordArn,
+                CA_ENDPOINT: caEndpoint,
+                PRIVATE_KEY_ARN: adminPrivateKeyArn,
+                SIGNED_CERT_ARN: adminSignedCertArn,
+                TLS_CERT_BUCKET: tlsBucketData.bucketName,
+                TLS_CERT_KEY: tlsBucketData.key,
+            },
+            role: customResourceRole,
+            vpc: client.vpc,
+            vpcSubnets: client.vpc.selectSubnets(),
+            timeout: cdk.Duration.minutes(1),
+        });
+        // Port range to access the Network
+        const ledgerPortRange = ec2.Port.tcpRange(utilities.STARTING_PORT, utilities.ENDING_PORT);
+        // Add access to the lambda for the Network ports
+        client.vpcEndpoint.connections.allowFrom(adminFunction, ledgerPortRange);
+        // Custom Resource provider
+        this.adminProvider = new customresources.Provider(this, 'AdminProvider', {
+            onEventHandler: adminFunction,
+            logRetention: logs.RetentionDays.ONE_DAY,
+        });
+        // Lambda function to register and enroll users and
+        // import credentials to secrets manager
+        const userFunction = new lambda.Function(scope, 'UserFunction', {
+            runtime: lambda.Runtime.NODEJS_14_X,
+            handler: 'register-user.handler',
+            code: lambda.Code.fromAsset(path.join(__dirname, '../lambdas/fabric')),
+            environment: {
+                CA_ENDPOINT: caEndpoint,
+                MEMBER_NAME: memberName,
+                PRIVATE_KEY_ARN: adminPrivateKeyArn,
+                SIGNED_CERT_ARN: adminSignedCertArn,
+                TLS_CERT_BUCKET: tlsBucketData.bucketName,
+                TLS_CERT_KEY: tlsBucketData.key,
+            },
+            role: customResourceRole,
+            vpc: client.vpc,
+            vpcSubnets: client.vpc.selectSubnets(),
+            timeout: cdk.Duration.minutes(1),
+        });
+        // Add access to the lambda for the Network ports
+        scope.client.vpcEndpoint.connections.allowFrom(userFunction, ledgerPortRange);
+        // Custom Resource provider
+        HyperledgerFabricIdentity.userProvider = new customresources.Provider(scope, 'UserProvider', {
+            onEventHandler: userFunction,
+            logRetention: logs.RetentionDays.ONE_DAY,
+        });
+        // Populate the custom role static variable
+        HyperledgerFabricIdentity.customRole = customResourceRole;
+    }
+}
+exports.HyperledgerFabricIdentity = HyperledgerFabricIdentity;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"identity.js","sourceRoot":"","sources":["../src/identity.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: MIT-0\n\nimport * as path from 'path';\nimport * as cdk from 'aws-cdk-lib';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport * as customresources from 'aws-cdk-lib/custom-resources';\nimport * as constructs from 'constructs';\n\nimport * as network from './network';\nimport * as utilities from './utilities';\n\n/**\n * Creates custom resources to enroll admin and register user\n * identities with the CA using the fabric-ca-client SDK.\n * Admin identity is enrolled by default. User identities are\n * registered and enrolled, if provided.\n */\nexport class HyperledgerFabricIdentity extends constructs.Construct {\n\n  /**\n   * Role for custom resource lambda to assume\n   */\n  public static customRole: iam.Role;\n\n  /**\n   * Custom provider to register user identity\n   */\n  public static userProvider: customresources.Provider;\n\n  /**\n   * Custom provider to enroll admin identity\n   */\n  public readonly adminProvider: customresources.Provider;\n\n\n  constructor(scope: network.HyperledgerFabricNetwork, id: string) {\n    super(scope, id);\n\n    // Collect metadata on the stack\n    const partition = cdk.Stack.of(this).partition;\n    const region = cdk.Stack.of(this).region;\n\n    // Retrieve the S3 Bucket and key that contains the TLS cert file\n    const tlsBucketData = utilities.getTlsBucket(region);\n\n    const adminPasswordArn = scope.adminPasswordSecret.secretArn;\n    const adminPrivateKeyArn = scope.adminPrivateKeySecret.secretArn;\n    const adminSignedCertArn = scope.adminSignedCertSecret.secretArn;\n    const caEndpoint = scope.caEndpoint;\n    const client = scope.client;\n    const memberName = scope.memberName;\n\n    // Role for the custom resource lambda functions\n    const customResourceRole = new iam.Role(this, 'CustomResourceRole', { assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com') });\n\n    // Policies for the custom resource lambda to enroll and register users\n    customResourceRole.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'));\n    customResourceRole.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaVPCAccessExecutionRole'));\n    customResourceRole.addToPolicy( new iam.PolicyStatement({\n      actions: ['s3:GetObject', 'secretsmanager:CreateSecret', 'secretsmanager:GetSecretValue', 'secretsmanager:PutSecretValue'],\n      resources: [\n        `arn:${partition}:s3:::${tlsBucketData.bucketName}/*`,\n        adminPasswordArn,\n        adminPrivateKeyArn,\n        adminSignedCertArn,\n      ],\n    }));\n\n    // Lambda function to enroll the admin and import credentials to secrets manager\n    const adminFunction = new lambda.Function(this, 'AdminFunction', {\n      runtime: lambda.Runtime.NODEJS_14_X,\n      handler: 'enroll-admin.handler',\n      code: lambda.Code.fromAsset(path.join(__dirname, '../lambdas/fabric')),\n      environment: {\n        ADMIN_PASSWORD_ARN: adminPasswordArn,\n        CA_ENDPOINT: caEndpoint,\n        PRIVATE_KEY_ARN: adminPrivateKeyArn,\n        SIGNED_CERT_ARN: adminSignedCertArn,\n        TLS_CERT_BUCKET: tlsBucketData.bucketName,\n        TLS_CERT_KEY: tlsBucketData.key,\n      },\n      role: customResourceRole,\n      vpc: client.vpc,\n      vpcSubnets: client.vpc.selectSubnets(),\n      timeout: cdk.Duration.minutes(1),\n    });\n\n    // Port range to access the Network\n    const ledgerPortRange = ec2.Port.tcpRange(utilities.STARTING_PORT, utilities.ENDING_PORT);\n\n    // Add access to the lambda for the Network ports\n    client.vpcEndpoint.connections.allowFrom(adminFunction, ledgerPortRange);\n\n    // Custom Resource provider\n    this.adminProvider = new customresources.Provider(this, 'AdminProvider', {\n      onEventHandler: adminFunction,\n      logRetention: logs.RetentionDays.ONE_DAY,\n    });\n\n    // Lambda function to register and enroll users and\n    // import credentials to secrets manager\n    const userFunction = new lambda.Function(scope, 'UserFunction', {\n      runtime: lambda.Runtime.NODEJS_14_X,\n      handler: 'register-user.handler',\n      code: lambda.Code.fromAsset(path.join(__dirname, '../lambdas/fabric')),\n      environment: {\n        CA_ENDPOINT: caEndpoint,\n        MEMBER_NAME: memberName,\n        PRIVATE_KEY_ARN: adminPrivateKeyArn,\n        SIGNED_CERT_ARN: adminSignedCertArn,\n        TLS_CERT_BUCKET: tlsBucketData.bucketName,\n        TLS_CERT_KEY: tlsBucketData.key,\n      },\n      role: customResourceRole,\n      vpc: client.vpc,\n      vpcSubnets: client.vpc.selectSubnets(),\n      timeout: cdk.Duration.minutes(1),\n    });\n\n    // Add access to the lambda for the Network ports\n    scope.client.vpcEndpoint.connections.allowFrom(userFunction, ledgerPortRange);\n\n    // Custom Resource provider\n    HyperledgerFabricIdentity.userProvider = new customresources.Provider(scope, 'UserProvider', {\n      onEventHandler: userFunction,\n      logRetention: logs.RetentionDays.ONE_DAY,\n    });\n\n    // Populate the custom role static variable\n    HyperledgerFabricIdentity.customRole = customResourceRole;\n\n  }\n\n}"]}

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './network';
+export * from './node';
+export * from './client';
+export * from './user';
+export { SUPPORTED_REGIONS, SUPPORTED_AVAILABILITY_ZONES } from './utilities';

package/lib/index.js

@@ -0,0 +1,22 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: MIT-0
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./network"), exports);
+__exportStar(require("./node"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./user"), exports);
+var utilities_1 = require("./utilities");
+Object.defineProperty(exports, "SUPPORTED_REGIONS", { enumerable: true, get: function () { return utilities_1.SUPPORTED_REGIONS; } });
+Object.defineProperty(exports, "SUPPORTED_AVAILABILITY_ZONES", { enumerable: true, get: function () { return utilities_1.SUPPORTED_AVAILABILITY_ZONES; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHFFQUFxRTtBQUNyRSxpQ0FBaUM7Ozs7Ozs7Ozs7OztBQUdqQyw0Q0FBMEI7QUFDMUIseUNBQXVCO0FBQ3ZCLDJDQUF5QjtBQUN6Qix5Q0FBdUI7QUFFdkIseUNBQThFO0FBQXJFLDhHQUFBLGlCQUFpQixPQUFBO0FBQUUseUhBQUEsNEJBQTRCLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgQW1hem9uLmNvbSwgSW5jLiBvciBpdHMgYWZmaWxpYXRlcy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVQtMFxuXG5cbmV4cG9ydCAqIGZyb20gJy4vbmV0d29yayc7XG5leHBvcnQgKiBmcm9tICcuL25vZGUnO1xuZXhwb3J0ICogZnJvbSAnLi9jbGllbnQnO1xuZXhwb3J0ICogZnJvbSAnLi91c2VyJztcblxuZXhwb3J0IHsgU1VQUE9SVEVEX1JFR0lPTlMsIFNVUFBPUlRFRF9BVkFJTEFCSUxJVFlfWk9ORVMgfSBmcm9tICcuL3V0aWxpdGllcyc7XG4iXX0=

package/lib/network.d.ts

@@ -0,0 +1,183 @@
+import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
+import * as constructs from 'constructs';
+import * as client from './client';
+import * as node from './node';
+import * as user from './user';
+export declare enum FrameworkVersion {
+    VERSION_1_2 = "1.2",
+    VERSION_1_4 = "1.4",
+    VERSION_2_2 = "2.2"
+}
+export declare enum NetworkEdition {
+    STARTER = "STARTER",
+    STANDARD = "STANDARD"
+}
+export declare enum ThresholdComparator {
+    GREATER_THAN = "GREATER_THAN",
+    GREATER_THAN_OR_EQUAL_TO = "GREATER_THAN_OR_EQUAL_TO"
+}
+/**
+ * Construct properties for `HyperledgerFabricNetwork`
+ */
+export interface HyperledgerFabricNetworkProps {
+    /**
+     * Managed Blockchain network name
+     */
+    readonly networkName: string;
+    /**
+     * Managed Blockchain network description
+     *
+     * @default - Set to match network name
+     */
+    readonly networkDescription?: string;
+    /**
+     * Managed Blockchain member name
+     */
+    readonly memberName: string;
+    /**
+     * Managed Blockchain member description
+     *
+     * @default - Set to match member name
+     */
+    readonly memberDescription?: string;
+    /**
+     * Hyperledger Fabric framework version
+     *
+     * @default - FrameworkVersion.VERSION_1_4
+     */
+    readonly frameworkVersion?: FrameworkVersion;
+    /**
+     * Managed Blockchain network edition
+     *
+     * @default - NetworkEdition.STANDARD
+     */
+    readonly networkEdition?: NetworkEdition;
+    /**
+     * The duration from the time that a proposal is created until it expires
+     * @default - 24 hours
+     */
+    readonly proposalDurationInHours?: number;
+    /**
+     * The percentage of votes among all members that must be yes for a proposal to be approved
+     * @default - 50 percent
+     */
+    readonly thresholdPercentage?: number;
+    /**
+     * Determines whether the yes votes must be greater than the threshold percentage
+     * or must be greater than or equal to the threhold percentage to be approved
+     * @default - GREATER_THAN
+     */
+    readonly thresholdComparator?: ThresholdComparator;
+    /**
+     * The configuration to enable or disable certificate authority logging
+     * @default - true
+     */
+    readonly enableCaLogging?: boolean;
+    /**
+     * List of nodes to create on the network
+     *
+     * @default - One node with default configuration
+     */
+    readonly nodes?: Array<node.HyperledgerFabricNodeProps>;
+    /**
+     * The Client network to interact with the Hyperledger Fabric network
+     * @default - Client network with Default properties
+     * (CIDR-`10.0.0.0/16` and subnets of type `PRIVATE_ISOLATED`)
+     */
+    readonly client?: client.HyperledgerFabricClientProps;
+    /**
+     * List of users to register with Fabric CA
+     */
+    readonly users?: Array<user.HyperledgerFabricUserProps>;
+}
+/**
+ * Creates a Hyperledger Fabric network on Amazon Managed Blockchain
+ */
+export declare class HyperledgerFabricNetwork extends constructs.Construct {
+    /**
+     * Managed Blockchain network name
+     */
+    readonly networkName: string;
+    /**
+     * Managed Blockchain network description
+     */
+    readonly networkDescription: string;
+    /**
+     * Managed Blockchain network identifier generated on construction
+     */
+    readonly networkId: string;
+    /**
+     * Managed Blockchain member name
+     */
+    readonly memberName: string;
+    /**
+     * Managed Blockchain member description
+     */
+    readonly memberDescription: string;
+    /**
+     * Managed Blockchain member identifier generated on construction
+     */
+    readonly memberId: string;
+    /**
+     * Hyperledger Fabric framework version
+     */
+    readonly frameworkVersion: FrameworkVersion;
+    /**
+     * Managed Blockchain network edition
+     */
+    readonly networkEdition: NetworkEdition;
+    /**
+     * The duration from the time that a proposal is created until it expires
+     */
+    readonly proposalDurationInHours: number;
+    /**
+     * The percentage of votes among all members that must be yes for a proposal to be approved
+     */
+    readonly thresholdPercentage: number;
+    /**
+     * Determines whether the yes votes must be greater than the threshold percentage
+     * or must be greater than or equal to the threhold percentage to be approved
+     */
+    readonly thresholdComparator: ThresholdComparator;
+    /**
+     * The configuration to enable or disable certificate authority logging
+     */
+    readonly enableCaLogging: boolean;
+    /**
+     * Managed Blockchain network VPC endpoint service name
+     */
+    readonly vpcEndpointServiceName: string;
+    /**
+     * Managed Blockchain network ordering service endpoint
+     */
+    readonly ordererEndpoint: string;
+    /**
+     * Managed Blockchain member CA endpoint
+     */
+    readonly caEndpoint: string;
+    /**
+     * Secret ARN for the Hyperledger Fabric admin password
+     */
+    readonly adminPasswordSecret: secretsmanager.Secret;
+    /**
+     * Secret for Hyperledger Fabric admin private key
+     */
+    readonly adminPrivateKeySecret: secretsmanager.Secret;
+    /**
+     * Secret for Hyperledger Fabric admin signed certificate
+     */
+    readonly adminSignedCertSecret: secretsmanager.Secret;
+    /**
+     * List of nodes created in the network
+     */
+    readonly nodes: Array<node.HyperledgerFabricNode>;
+    /**
+     * The client network to interact with the Hyperledger Fabric network
+     */
+    readonly client: client.HyperledgerFabricClient;
+    /**
+     * List of users registered with CA
+     */
+    readonly users: Array<user.HyperledgerFabricUser>;
+    constructor(scope: constructs.Construct, id: string, props: HyperledgerFabricNetworkProps);
+}

package/lib/network.js

@@ -0,0 +1,225 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperledgerFabricNetwork = exports.ThresholdComparator = exports.NetworkEdition = exports.FrameworkVersion = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: MIT-0
+const cdk = require("aws-cdk-lib");
+const managedblockchain = require("aws-cdk-lib/aws-managedblockchain");
+const secretsmanager = require("aws-cdk-lib/aws-secretsmanager");
+const customresources = require("aws-cdk-lib/custom-resources");
+const constructs = require("constructs");
+const client = require("./client");
+const identity = require("./identity");
+const node = require("./node");
+const user = require("./user");
+const utilities = require("./utilities");
+/*
+ * Define which Hyperledger Fabric framework to use
+ */
+var FrameworkVersion;
+(function (FrameworkVersion) {
+    FrameworkVersion["VERSION_1_2"] = "1.2";
+    FrameworkVersion["VERSION_1_4"] = "1.4";
+    FrameworkVersion["VERSION_2_2"] = "2.2";
+})(FrameworkVersion = exports.FrameworkVersion || (exports.FrameworkVersion = {}));
+/*
+ * Starter networks are cheaper, but are limited to 2 nodes that
+ * can only be from a subset of types (see node.ts for the list)
+ */
+var NetworkEdition;
+(function (NetworkEdition) {
+    NetworkEdition["STARTER"] = "STARTER";
+    NetworkEdition["STANDARD"] = "STANDARD";
+})(NetworkEdition = exports.NetworkEdition || (exports.NetworkEdition = {}));
+/*
+ * Constants to define ties in voting for new members
+ */
+var ThresholdComparator;
+(function (ThresholdComparator) {
+    ThresholdComparator["GREATER_THAN"] = "GREATER_THAN";
+    ThresholdComparator["GREATER_THAN_OR_EQUAL_TO"] = "GREATER_THAN_OR_EQUAL_TO";
+})(ThresholdComparator = exports.ThresholdComparator || (exports.ThresholdComparator = {}));
+/**
+ * Creates a Hyperledger Fabric network on Amazon Managed Blockchain
+ */
+class HyperledgerFabricNetwork extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        // Collect metadata on the stack
+        const partition = cdk.Stack.of(this).partition;
+        const region = cdk.Stack.of(this).region;
+        const account = cdk.Stack.of(this).account;
+        // Populate instance variables from input properties, using defaults if values not provided
+        this.networkName = props.networkName;
+        this.networkDescription = props.networkDescription ?? props.networkName;
+        this.memberName = props.memberName;
+        this.memberDescription = props.memberDescription ?? props.memberName;
+        this.frameworkVersion = props.frameworkVersion ?? FrameworkVersion.VERSION_1_4;
+        this.networkEdition = props.networkEdition ?? NetworkEdition.STANDARD;
+        this.proposalDurationInHours = props.proposalDurationInHours ?? 24;
+        this.thresholdPercentage = props.thresholdPercentage ?? 50;
+        this.thresholdComparator = props.thresholdComparator ?? ThresholdComparator.GREATER_THAN;
+        this.enableCaLogging = props.enableCaLogging ?? true;
+        this.users = [];
+        // Ensure the parameters captured above are valid, so we don't
+        // need to wait until deployment time to discover an error
+        utilities.validateRegion(region);
+        if (!utilities.validateString(this.networkName, 1, 64)) {
+            throw new Error('Network name is invalid or not provided. It can be up to 64 characters long.');
+        }
+        if (!utilities.validateString(this.networkDescription, 0, 128)) {
+            throw new Error('Network description is invalid. It can be up to 128 characters long.');
+        }
+        if (!utilities.validateString(this.memberName, 1, 64, /^(?!-|[0-9])(?!.*-$)(?!.*?--)[a-zA-Z0-9-]+$/)) {
+            throw new Error('Member name is invalid or not provided. It can be up to 64 characters long, and can have alphanumeric characters and hyphen(s). It cannot start with a number, or start and end with a hyphen (-), or have two consecutive hyphens. The member name must also be unique across the network.');
+        }
+        if (!utilities.validateString(this.memberDescription, 0, 128)) {
+            throw new Error('Member description is invalid. It can be up to 128 characters long.');
+        }
+        if (!utilities.validateInteger(this.proposalDurationInHours, 1, 168)) {
+            throw new Error('Voting policy proposal duration must be between 1 and 168 hours.');
+        }
+        if (!utilities.validateInteger(this.thresholdPercentage, 0, 100)) {
+            throw new Error('Voting policy threshold percentage must be between 0 and 100.');
+        }
+        // Ensure the user affiliation includes the member name,
+        // if the user list for registration is provided
+        if (props.users) {
+            props.users.forEach(e => {
+                if (!e.affilitation.startsWith(this.memberName))
+                    throw new Error('User affiliation is invalid. Affiliation should start with Member name');
+            });
+        }
+        // Per the Managed Blockchain documentation, the admin password must be at least eight
+        // characters long and no more than 32 characters. It must contain at least one uppercase
+        // letter, one lowercase letter, and one digit. It cannot have a single quotation mark (‘),
+        // a double quotation marks (“), a forward slash(/), a backward slash(\), @, or a space;
+        // several other characters are exluded here to make the password easier to use in scripts
+        const passwordRequirements = {
+            passwordLength: 32,
+            requireEachIncludedType: true,
+            excludeCharacters: '\'"/\\@ &{}<>*|',
+        };
+        this.adminPasswordSecret = new secretsmanager.Secret(this, 'AdminPassword', { generateSecretString: passwordRequirements });
+        // The initially enrolled admin user credentials will be stored in these secrets
+        this.adminPrivateKeySecret = new secretsmanager.Secret(this, 'AdminPrivateKey');
+        this.adminSignedCertSecret = new secretsmanager.Secret(this, 'AdminSignedCert');
+        // Build out the Cloudformation construct for the network/member
+        const networkConfiguration = {
+            name: this.networkName,
+            description: this.networkDescription,
+            framework: 'HYPERLEDGER_FABRIC',
+            frameworkVersion: this.frameworkVersion,
+            networkFrameworkConfiguration: {
+                networkFabricConfiguration: {
+                    edition: this.networkEdition,
+                },
+            },
+            votingPolicy: {
+                approvalThresholdPolicy: {
+                    proposalDurationInHours: this.proposalDurationInHours,
+                    thresholdPercentage: this.thresholdPercentage,
+                    thresholdComparator: this.thresholdComparator,
+                },
+            },
+        };
+        // Note the use of the unwrap below is the only possible way to get
+        // the secret value into the CloudFormation; it will still not directly
+        // be included in the synthesized template so usage here is still safe
+        const memberConfiguration = {
+            name: this.memberName,
+            description: this.memberDescription,
+            memberFrameworkConfiguration: {
+                memberFabricConfiguration: {
+                    adminUsername: 'admin',
+                    adminPassword: this.adminPasswordSecret.secretValue.unsafeUnwrap(),
+                },
+            },
+        };
+        const network = new managedblockchain.CfnMember(this, 'Network', { networkConfiguration, memberConfiguration });
+        // Capture data included in the Cloudformation output in instance variables
+        this.networkId = network.getAtt('NetworkId').toString();
+        this.memberId = network.getAtt('MemberId').toString();
+        // Build out the associated node constructs
+        this.nodes = node.HyperledgerFabricNode.constructNodes(this, props.nodes);
+        // Due to a race condition in CDK custom resources (https://github.com/aws/aws-cdk/issues/18237),
+        // the necessary permissions for all SDK calls in the stack need to be added here, even though
+        // the calls in this construct don't need access to the nodes; this also means node constructs
+        // can't populate their outputs fully until later, which is annoying
+        const nodeIds = this.nodes.map(n => n.nodeId);
+        const nodeArns = nodeIds.map(i => `arn:${partition}:managedblockchain:${region}:${account}:nodes/${i}`);
+        const sdkCallPolicy = customresources.AwsCustomResourcePolicy.fromSdkCalls({
+            resources: [
+                `arn:${partition}:managedblockchain:${region}::networks/${this.networkId}`,
+                `arn:${partition}:managedblockchain:${region}:${account}:members/${this.memberId}`,
+                ...nodeArns,
+            ],
+        });
+        // Cloudformation doesn't include all the network and member attributes
+        // needed to use Hyperledger Fabric, so use SDK calls to fetch said data
+        const networkDataSdkCall = {
+            service: 'ManagedBlockchain',
+            action: 'getNetwork',
+            parameters: { NetworkId: this.networkId },
+            physicalResourceId: customresources.PhysicalResourceId.of('Id'),
+        };
+        const memberDataSdkCall = {
+            service: 'ManagedBlockchain',
+            action: 'getMember',
+            parameters: { NetworkId: this.networkId, MemberId: this.memberId },
+            physicalResourceId: customresources.PhysicalResourceId.of('Id'),
+        };
+        // Data items need fetching on creation and updating; nothing needs doing on deletion
+        const networkData = new customresources.AwsCustomResource(this, 'NetworkDataResource', {
+            policy: sdkCallPolicy,
+            onCreate: networkDataSdkCall,
+            onUpdate: networkDataSdkCall,
+        });
+        const memberData = new customresources.AwsCustomResource(this, 'MemberDataResource', {
+            policy: sdkCallPolicy,
+            onCreate: memberDataSdkCall,
+            onUpdate: memberDataSdkCall,
+        });
+        // Cloudformation doesn't include logging configuration so use SDK call to do so
+        const logConfiguration = {
+            Fabric: { CaLogs: { Cloudwatch: { Enabled: this.enableCaLogging } } },
+        };
+        const configureCaLogSdkCall = {
+            service: 'ManagedBlockchain',
+            action: 'updateMember',
+            parameters: { NetworkId: this.networkId, MemberId: this.memberId, LogPublishingConfiguration: logConfiguration },
+            physicalResourceId: customresources.PhysicalResourceId.of('Id'),
+        };
+        new customresources.AwsCustomResource(this, 'ConfigureCaLogResource', {
+            policy: sdkCallPolicy,
+            onCreate: configureCaLogSdkCall,
+            onUpdate: configureCaLogSdkCall,
+        });
+        // Grab items out of the above return values and stick them in output properties
+        this.vpcEndpointServiceName = networkData.getResponseField('Network.VpcEndpointServiceName');
+        this.ordererEndpoint = networkData.getResponseField('Network.FrameworkAttributes.Fabric.OrderingServiceEndpoint');
+        this.caEndpoint = memberData.getResponseField('Member.FrameworkAttributes.Fabric.CaEndpoint');
+        // As stated earlier, node constructs can't populate all their properties
+        // until after the above network and member SDK calls succeed; thus the
+        // function calls below where fetches are split out and logging is configured
+        for (const n of this.nodes) {
+            n.configureLogging(sdkCallPolicy);
+            n.fetchData(sdkCallPolicy);
+        }
+        // Build out the client VPC construct
+        this.client = new client.HyperledgerFabricClient(this, 'NetworkClient', props.client);
+        // Build out all the custom resources to register and enroll identities to CA
+        const identityResources = new identity.HyperledgerFabricIdentity(this, 'Identity');
+        // Enroll the administrator and store its credentials on Secrets Manager
+        new cdk.CustomResource(this, 'AdminCustomResource', { serviceToken: identityResources.adminProvider.serviceToken });
+        // Register and enroll users, if provided
+        if (props.users)
+            this.users = Array.from(props.users.entries()).map(e => new user.HyperledgerFabricUser(this, `User${e[0]}`, e[1]));
+    }
+}
+exports.HyperledgerFabricNetwork = HyperledgerFabricNetwork;
+_a = JSII_RTTI_SYMBOL_1;
+HyperledgerFabricNetwork[_a] = { fqn: "@cdklabs/cdk-hyperledger-fabric-network.HyperledgerFabricNetwork", version: "0.0.20" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network.js","sourceRoot":"","sources":["../src/network.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: MIT-0\n\n\nimport * as cdk from 'aws-cdk-lib';\nimport * as managedblockchain from 'aws-cdk-lib/aws-managedblockchain';\nimport * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';\nimport * as customresources from 'aws-cdk-lib/custom-resources';\nimport * as constructs from 'constructs';\n\nimport * as client from './client';\nimport * as identity from './identity';\nimport * as node from './node';\nimport * as user from './user';\nimport * as utilities from './utilities';\n\n\n/*\n * Define which Hyperledger Fabric framework to use\n */\nexport enum FrameworkVersion {\n  VERSION_1_2 = '1.2',\n  VERSION_1_4 = '1.4',\n  VERSION_2_2 = '2.2',\n}\n\n/*\n * Starter networks are cheaper, but are limited to 2 nodes that\n * can only be from a subset of types (see node.ts for the list)\n */\nexport enum NetworkEdition {\n  STARTER = 'STARTER',\n  STANDARD = 'STANDARD',\n}\n\n/*\n * Constants to define ties in voting for new members\n */\nexport enum ThresholdComparator {\n  GREATER_THAN = 'GREATER_THAN',\n  GREATER_THAN_OR_EQUAL_TO = 'GREATER_THAN_OR_EQUAL_TO',\n}\n\n\n/**\n * Construct properties for `HyperledgerFabricNetwork`\n */\nexport interface HyperledgerFabricNetworkProps {\n\n  /**\n   * Managed Blockchain network name\n   */\n  readonly networkName: string;\n\n  /**\n   * Managed Blockchain network description\n   *\n   * @default - Set to match network name\n   */\n  readonly networkDescription?: string;\n\n  /**\n   * Managed Blockchain member name\n   */\n  readonly memberName: string;\n\n  /**\n   * Managed Blockchain member description\n   *\n   * @default - Set to match member name\n   */\n  readonly memberDescription?: string;\n\n  /**\n   * Hyperledger Fabric framework version\n   *\n   * @default - FrameworkVersion.VERSION_1_4\n   */\n  readonly frameworkVersion?: FrameworkVersion;\n\n  /**\n   * Managed Blockchain network edition\n   *\n   * @default - NetworkEdition.STANDARD\n   */\n  readonly networkEdition?: NetworkEdition;\n\n  /**\n   * The duration from the time that a proposal is created until it expires\n   * @default - 24 hours\n   */\n  readonly proposalDurationInHours?: number;\n\n  /**\n   * The percentage of votes among all members that must be yes for a proposal to be approved\n   * @default - 50 percent\n   */\n  readonly thresholdPercentage?: number;\n\n  /**\n   * Determines whether the yes votes must be greater than the threshold percentage\n   * or must be greater than or equal to the threhold percentage to be approved\n   * @default - GREATER_THAN\n   */\n  readonly thresholdComparator?: ThresholdComparator;\n\n  /**\n   * The configuration to enable or disable certificate authority logging\n   * @default - true\n   */\n  readonly enableCaLogging?: boolean;\n\n  /**\n   * List of nodes to create on the network\n   *\n   * @default - One node with default configuration\n   */\n  readonly nodes?: Array<node.HyperledgerFabricNodeProps>;\n\n  /**\n   * The Client network to interact with the Hyperledger Fabric network\n   * @default - Client network with Default properties\n   * (CIDR-`10.0.0.0/16` and subnets of type `PRIVATE_ISOLATED`)\n   */\n  readonly client?: client.HyperledgerFabricClientProps;\n\n  /**\n   * List of users to register with Fabric CA\n   */\n  readonly users?: Array<user.HyperledgerFabricUserProps>;\n\n}\n\n\n/**\n * Creates a Hyperledger Fabric network on Amazon Managed Blockchain\n */\nexport class HyperledgerFabricNetwork extends constructs.Construct {\n\n  /**\n   * Managed Blockchain network name\n   */\n  public readonly networkName: string;\n\n  /**\n   * Managed Blockchain network description\n   */\n  public readonly networkDescription: string;\n\n  /**\n   * Managed Blockchain network identifier generated on construction\n   */\n  public readonly networkId: string;\n\n  /**\n   * Managed Blockchain member name\n   */\n  public readonly memberName: string;\n\n  /**\n   * Managed Blockchain member description\n   */\n  public readonly memberDescription: string;\n\n  /**\n   * Managed Blockchain member identifier generated on construction\n   */\n  public readonly memberId: string;\n\n  /**\n   * Hyperledger Fabric framework version\n   */\n  public readonly frameworkVersion: FrameworkVersion;\n\n  /**\n   * Managed Blockchain network edition\n   */\n  public readonly networkEdition: NetworkEdition;\n\n  /**\n   * The duration from the time that a proposal is created until it expires\n   */\n  public readonly proposalDurationInHours: number;\n\n  /**\n   * The percentage of votes among all members that must be yes for a proposal to be approved\n   */\n  public readonly thresholdPercentage: number;\n\n  /**\n   * Determines whether the yes votes must be greater than the threshold percentage\n   * or must be greater than or equal to the threhold percentage to be approved\n   */\n  public readonly thresholdComparator: ThresholdComparator;\n\n  /**\n   * The configuration to enable or disable certificate authority logging\n   */\n  public readonly enableCaLogging: boolean;\n\n  /**\n   * Managed Blockchain network VPC endpoint service name\n   */\n  public readonly vpcEndpointServiceName: string;\n\n  /**\n   * Managed Blockchain network ordering service endpoint\n   */\n  public readonly ordererEndpoint: string;\n\n  /**\n   * Managed Blockchain member CA endpoint\n   */\n  public readonly caEndpoint: string;\n\n  /**\n   * Secret ARN for the Hyperledger Fabric admin password\n   */\n  public readonly adminPasswordSecret: secretsmanager.Secret;\n\n  /**\n   * Secret for Hyperledger Fabric admin private key\n   */\n  public readonly adminPrivateKeySecret: secretsmanager.Secret;\n\n  /**\n   * Secret for Hyperledger Fabric admin signed certificate\n   */\n  public readonly adminSignedCertSecret: secretsmanager.Secret;\n\n  /**\n   * List of nodes created in the network\n   */\n  public readonly nodes: Array<node.HyperledgerFabricNode>;\n\n  /**\n   * The client network to interact with the Hyperledger Fabric network\n   */\n  public readonly client: client.HyperledgerFabricClient;\n\n  /**\n   * List of users registered with CA\n   */\n  public readonly users: Array<user.HyperledgerFabricUser>;\n\n\n  constructor(scope: constructs.Construct, id: string, props: HyperledgerFabricNetworkProps) {\n\n    super(scope, id);\n\n    // Collect metadata on the stack\n    const partition = cdk.Stack.of(this).partition;\n    const region = cdk.Stack.of(this).region;\n    const account = cdk.Stack.of(this).account;\n\n    // Populate instance variables from input properties, using defaults if values not provided\n    this.networkName = props.networkName;\n    this.networkDescription = props.networkDescription ?? props.networkName;\n    this.memberName = props.memberName;\n    this.memberDescription = props.memberDescription ?? props.memberName;\n    this.frameworkVersion = props.frameworkVersion ?? FrameworkVersion.VERSION_1_4;\n    this.networkEdition = props.networkEdition ?? NetworkEdition.STANDARD;\n    this.proposalDurationInHours = props.proposalDurationInHours ?? 24;\n    this.thresholdPercentage = props.thresholdPercentage ?? 50;\n    this.thresholdComparator = props.thresholdComparator ?? ThresholdComparator.GREATER_THAN;\n    this.enableCaLogging = props.enableCaLogging ?? true;\n    this.users = [];\n\n    // Ensure the parameters captured above are valid, so we don't\n    // need to wait until deployment time to discover an error\n    utilities.validateRegion(region);\n    if (!utilities.validateString(this.networkName, 1, 64)) {\n      throw new Error('Network name is invalid or not provided. It can be up to 64 characters long.');\n    }\n    if (!utilities.validateString(this.networkDescription, 0, 128)) {\n      throw new Error('Network description is invalid. It can be up to 128 characters long.');\n    }\n    if (!utilities.validateString(this.memberName, 1, 64, /^(?!-|[0-9])(?!.*-$)(?!.*?--)[a-zA-Z0-9-]+$/)) {\n      throw new Error('Member name is invalid or not provided. It can be up to 64 characters long, and can have alphanumeric characters and hyphen(s). It cannot start with a number, or start and end with a hyphen (-), or have two consecutive hyphens. The member name must also be unique across the network.');\n    }\n    if (!utilities.validateString(this.memberDescription, 0, 128)) {\n      throw new Error('Member description is invalid. It can be up to 128 characters long.');\n    }\n    if (!utilities.validateInteger(this.proposalDurationInHours, 1, 168)) {\n      throw new Error('Voting policy proposal duration must be between 1 and 168 hours.');\n    }\n    if (!utilities.validateInteger(this.thresholdPercentage, 0, 100)) {\n      throw new Error('Voting policy threshold percentage must be between 0 and 100.');\n    }\n\n    // Ensure the user affiliation includes the member name,\n    // if the user list for registration is provided\n    if (props.users) {\n      props.users.forEach(e => {\n        if (!e.affilitation.startsWith(this.memberName)) throw new Error('User affiliation is invalid. Affiliation should start with Member name');\n      });\n    }\n\n    // Per the Managed Blockchain documentation, the admin password must be at least eight\n    // characters long and no more than 32 characters. It must contain at least one uppercase\n    // letter, one lowercase letter, and one digit. It cannot have a single quotation mark (‘),\n    // a double quotation marks (“), a forward slash(/), a backward slash(\\), @, or a space;\n    // several other characters are exluded here to make the password easier to use in scripts\n    const passwordRequirements = {\n      passwordLength: 32,\n      requireEachIncludedType: true,\n      excludeCharacters: '\\'\"/\\\\@ &{}<>*|',\n    };\n    this.adminPasswordSecret = new secretsmanager.Secret(this, 'AdminPassword', { generateSecretString: passwordRequirements });\n\n    // The initially enrolled admin user credentials will be stored in these secrets\n    this.adminPrivateKeySecret = new secretsmanager.Secret(this, 'AdminPrivateKey');\n    this.adminSignedCertSecret = new secretsmanager.Secret(this, 'AdminSignedCert');\n\n    // Build out the Cloudformation construct for the network/member\n    const networkConfiguration = {\n      name: this.networkName,\n      description: this.networkDescription,\n      framework: 'HYPERLEDGER_FABRIC',\n      frameworkVersion: this.frameworkVersion,\n      networkFrameworkConfiguration: {\n        networkFabricConfiguration: {\n          edition: this.networkEdition,\n        },\n      },\n      votingPolicy: {\n        approvalThresholdPolicy: {\n          proposalDurationInHours: this.proposalDurationInHours,\n          thresholdPercentage: this.thresholdPercentage,\n          thresholdComparator: this.thresholdComparator,\n        },\n      },\n    };\n\n    // Note the use of the unwrap below is the only possible way to get\n    // the secret value into the CloudFormation; it will still not directly\n    // be included in the synthesized template so usage here is still safe\n    const memberConfiguration = {\n      name: this.memberName,\n      description: this.memberDescription,\n      memberFrameworkConfiguration: {\n        memberFabricConfiguration: {\n          adminUsername: 'admin',\n          adminPassword: this.adminPasswordSecret.secretValue.unsafeUnwrap(),\n        },\n      },\n    };\n    const network = new managedblockchain.CfnMember(this, 'Network', { networkConfiguration, memberConfiguration });\n\n    // Capture data included in the Cloudformation output in instance variables\n    this.networkId = network.getAtt('NetworkId').toString();\n    this.memberId = network.getAtt('MemberId').toString();\n\n    // Build out the associated node constructs\n    this.nodes = node.HyperledgerFabricNode.constructNodes(this, props.nodes);\n\n    // Due to a race condition in CDK custom resources (https://github.com/aws/aws-cdk/issues/18237),\n    // the necessary permissions for all SDK calls in the stack need to be added here, even though\n    // the calls in this construct don't need access to the nodes; this also means node constructs\n    // can't populate their outputs fully until later, which is annoying\n    const nodeIds = this.nodes.map(n => n.nodeId);\n    const nodeArns = nodeIds.map(i => `arn:${partition}:managedblockchain:${region}:${account}:nodes/${i}`);\n    const sdkCallPolicy = customresources.AwsCustomResourcePolicy.fromSdkCalls({\n      resources: [\n        `arn:${partition}:managedblockchain:${region}::networks/${this.networkId}`,\n        `arn:${partition}:managedblockchain:${region}:${account}:members/${this.memberId}`,\n        ...nodeArns,\n      ],\n    });\n\n    // Cloudformation doesn't include all the network and member attributes\n    // needed to use Hyperledger Fabric, so use SDK calls to fetch said data\n    const networkDataSdkCall = {\n      service: 'ManagedBlockchain',\n      action: 'getNetwork',\n      parameters: { NetworkId: this.networkId },\n      physicalResourceId: customresources.PhysicalResourceId.of('Id'),\n    };\n    const memberDataSdkCall = {\n      service: 'ManagedBlockchain',\n      action: 'getMember',\n      parameters: { NetworkId: this.networkId, MemberId: this.memberId },\n      physicalResourceId: customresources.PhysicalResourceId.of('Id'),\n    };\n\n    // Data items need fetching on creation and updating; nothing needs doing on deletion\n    const networkData = new customresources.AwsCustomResource(this, 'NetworkDataResource', {\n      policy: sdkCallPolicy,\n      onCreate: networkDataSdkCall,\n      onUpdate: networkDataSdkCall,\n    });\n    const memberData = new customresources.AwsCustomResource(this, 'MemberDataResource', {\n      policy: sdkCallPolicy,\n      onCreate: memberDataSdkCall,\n      onUpdate: memberDataSdkCall,\n    });\n\n    // Cloudformation doesn't include logging configuration so use SDK call to do so\n    const logConfiguration = {\n      Fabric: { CaLogs: { Cloudwatch: { Enabled: this.enableCaLogging } } },\n    };\n    const configureCaLogSdkCall = {\n      service: 'ManagedBlockchain',\n      action: 'updateMember',\n      parameters: { NetworkId: this.networkId, MemberId: this.memberId, LogPublishingConfiguration: logConfiguration },\n      physicalResourceId: customresources.PhysicalResourceId.of('Id'),\n    };\n    new customresources.AwsCustomResource(this, 'ConfigureCaLogResource', {\n      policy: sdkCallPolicy,\n      onCreate: configureCaLogSdkCall,\n      onUpdate: configureCaLogSdkCall,\n    });\n\n    // Grab items out of the above return values and stick them in output properties\n    this.vpcEndpointServiceName = networkData.getResponseField('Network.VpcEndpointServiceName');\n    this.ordererEndpoint = networkData.getResponseField('Network.FrameworkAttributes.Fabric.OrderingServiceEndpoint');\n    this.caEndpoint = memberData.getResponseField('Member.FrameworkAttributes.Fabric.CaEndpoint');\n\n    // As stated earlier, node constructs can't populate all their properties\n    // until after the above network and member SDK calls succeed; thus the\n    // function calls below where fetches are split out and logging is configured\n    for (const n of this.nodes) {\n      n.configureLogging(sdkCallPolicy);\n      n.fetchData(sdkCallPolicy);\n    }\n\n    // Build out the client VPC construct\n    this.client = new client.HyperledgerFabricClient(this, 'NetworkClient', props.client);\n\n    // Build out all the custom resources to register and enroll identities to CA\n    const identityResources = new identity.HyperledgerFabricIdentity(this, 'Identity');\n\n    // Enroll the administrator and store its credentials on Secrets Manager\n    new cdk.CustomResource(this, 'AdminCustomResource', { serviceToken: identityResources.adminProvider.serviceToken });\n\n    // Register and enroll users, if provided\n    if (props.users) this.users = Array.from(props.users.entries()).map(e => new user.HyperledgerFabricUser(this, `User${e[0]}`, e[1]));\n  }\n\n}\n"]}