@push.rocks/smartacme 4.0.3

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2016, Lossless GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@pushrocks/smartacme',
+    version: '4.0.3',
+    description: 'acme with an easy yet powerful interface in TypeScript'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxzQkFBc0I7SUFDNUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHdEQUF3RDtDQUN0RSxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -0,0 +1 @@
+export * from './smartacme.classes.smartacme.js';

package/dist_ts/index.js

@@ -0,0 +1,2 @@
+export * from './smartacme.classes.smartacme.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtDQUFrQyxDQUFDIn0=

package/dist_ts/interfaces/accountdata.d.ts

@@ -0,0 +1,13 @@
+export interface IAccountData {
+    id: number;
+    key: {
+        kty: 'RSA';
+        n: string;
+        e: string;
+        kid: string;
+    };
+    contact: string[];
+    initialIp: string;
+    createdAt: string;
+    status: string;
+}

package/dist_ts/interfaces/accountdata.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudGRhdGEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbnRlcmZhY2VzL2FjY291bnRkYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist_ts/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from './accountdata.js';

package/dist_ts/interfaces/index.js

@@ -0,0 +1,2 @@
+export * from './accountdata.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbnRlcmZhY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsa0JBQWtCLENBQUMifQ==

package/dist_ts/smartacme.classes.cert.d.ts

@@ -0,0 +1,14 @@
+import * as plugins from './smartacme.plugins.js';
+export declare class Cert extends plugins.smartdata.SmartDataDbDoc<Cert, plugins.tsclass.network.ICert> implements plugins.tsclass.network.ICert {
+    id: string;
+    domainName: string;
+    created: number;
+    privateKey: string;
+    publicKey: string;
+    csr: string;
+    validUntil: number;
+    isStillValid(): boolean;
+    shouldBeRenewed(): boolean;
+    update(certDataArg: plugins.tsclass.network.ICert): void;
+    constructor(optionsArg: plugins.tsclass.network.ICert);
+}

package/dist_ts/smartacme.classes.cert.js

@@ -0,0 +1,74 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import * as plugins from './smartacme.plugins.js';
+import './interfaces/index.js';
+import { CertManager } from './smartacme.classes.certmanager.js';
+import { svDb, unI } from '@pushrocks/smartdata';
+let Cert = class Cert extends plugins.smartdata.SmartDataDbDoc {
+    isStillValid() {
+        return this.validUntil >= Date.now();
+    }
+    shouldBeRenewed() {
+        const shouldBeValidAtLeastUntil = Date.now() +
+            plugins.smarttime.getMilliSecondsFromUnits({
+                days: 10,
+            });
+        return !(this.validUntil >= shouldBeValidAtLeastUntil);
+    }
+    update(certDataArg) {
+        Object.keys(certDataArg).forEach((key) => {
+            this[key] = certDataArg[key];
+        });
+    }
+    constructor(optionsArg) {
+        super();
+        if (optionsArg) {
+            Object.keys(optionsArg).forEach((key) => {
+                this[key] = optionsArg[key];
+            });
+        }
+    }
+};
+__decorate([
+    unI(),
+    __metadata("design:type", String)
+], Cert.prototype, "id", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", String)
+], Cert.prototype, "domainName", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", Number)
+], Cert.prototype, "created", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", String)
+], Cert.prototype, "privateKey", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", String)
+], Cert.prototype, "publicKey", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", String)
+], Cert.prototype, "csr", void 0);
+__decorate([
+    svDb(),
+    __metadata("design:type", Number)
+], Cert.prototype, "validUntil", void 0);
+Cert = __decorate([
+    plugins.smartdata.Collection(() => {
+        return CertManager.activeDB;
+    }),
+    __metadata("design:paramtypes", [Object])
+], Cert);
+export { Cert };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhY21lLmNsYXNzZXMuY2VydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0YWNtZS5jbGFzc2VzLmNlcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSx3QkFBd0IsQ0FBQztBQUVsRCxPQUE0Qix1QkFBdUIsQ0FBQztBQUVwRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFFakUsT0FBTyxFQUFjLElBQUksRUFBRSxHQUFHLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUt0RCxJQUFNLElBQUksR0FBVixNQUFNLElBQUssU0FBUSxPQUFPLENBQUMsU0FBUyxDQUFDLGNBQW1EO0lBdUJ0RixZQUFZO1FBQ2pCLE9BQU8sSUFBSSxDQUFDLFVBQVUsSUFBSSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7SUFDdkMsQ0FBQztJQUVNLGVBQWU7UUFDcEIsTUFBTSx5QkFBeUIsR0FDN0IsSUFBSSxDQUFDLEdBQUcsRUFBRTtZQUNWLE9BQU8sQ0FBQyxTQUFTLENBQUMsd0JBQXdCLENBQUM7Z0JBQ3pDLElBQUksRUFBRSxFQUFFO2FBQ1QsQ0FBQyxDQUFDO1FBQ0wsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLFVBQVUsSUFBSSx5QkFBeUIsQ0FBQyxDQUFDO0lBQ3pELENBQUM7SUFFTSxNQUFNLENBQUMsV0FBMEM7UUFDdEQsTUFBTSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRTtZQUN2QyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsV0FBVyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQy9CLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELFlBQVksVUFBeUM7UUFDbkQsS0FBSyxFQUFFLENBQUM7UUFDUixJQUFJLFVBQVUsRUFBRTtZQUNkLE1BQU0sQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUU7Z0JBQ3RDLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUM7WUFDOUIsQ0FBQyxDQUFDLENBQUM7U0FDSjtJQUNILENBQUM7Q0FDRixDQUFBO0FBaERDO0lBQUMsR0FBRyxFQUFFOztnQ0FDWTtBQUVsQjtJQUFDLElBQUksRUFBRTs7d0NBQ21CO0FBRTFCO0lBQUMsSUFBSSxFQUFFOztxQ0FDZ0I7QUFFdkI7SUFBQyxJQUFJLEVBQUU7O3dDQUNtQjtBQUUxQjtJQUFDLElBQUksRUFBRTs7dUNBQ2tCO0FBRXpCO0lBQUMsSUFBSSxFQUFFOztpQ0FDWTtBQUVuQjtJQUFDLElBQUksRUFBRTs7d0NBQ21CO0FBckJmLElBQUk7SUFIaEIsT0FBTyxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsR0FBRyxFQUFFO1FBQ2pDLE9BQU8sV0FBVyxDQUFDLFFBQVEsQ0FBQztJQUM5QixDQUFDLENBQUM7O0dBQ1csSUFBSSxDQWtEaEI7U0FsRFksSUFBSSJ9

package/dist_ts/smartacme.classes.certmanager.d.ts

@@ -0,0 +1,25 @@
+import * as plugins from './smartacme.plugins.js';
+import { Cert } from './smartacme.classes.cert.js';
+import { SmartAcme } from './smartacme.classes.smartacme.js';
+export declare class CertManager {
+    static activeDB: plugins.smartdata.SmartdataDb;
+    private mongoDescriptor;
+    smartdataDb: plugins.smartdata.SmartdataDb;
+    interestMap: plugins.lik.InterestMap<string, Cert>;
+    constructor(smartAcmeArg: SmartAcme, optionsArg: {
+        mongoDescriptor: plugins.smartdata.IMongoDescriptor;
+    });
+    init(): Promise<void>;
+    /**
+     * retrieves a certificate
+     * @returns the Cert class or null
+     * @param certDomainNameArg the domain Name to retrieve the vcertificate for
+     */
+    retrieveCertificate(certDomainNameArg: string): Promise<Cert>;
+    /**
+     * stores the certificate
+     * @param optionsArg
+     */
+    storeCertificate(optionsArg: plugins.tsclass.network.ICert): Promise<void>;
+    deleteCertificate(certDomainNameArg: string): Promise<void>;
+}

package/dist_ts/smartacme.classes.certmanager.js

@@ -0,0 +1,53 @@
+import * as plugins from './smartacme.plugins.js';
+import { Cert } from './smartacme.classes.cert.js';
+import './smartacme.classes.smartacme.js';
+import './interfaces/index.js';
+export class CertManager {
+    constructor(smartAcmeArg, optionsArg) {
+        this.mongoDescriptor = optionsArg.mongoDescriptor;
+    }
+    async init() {
+        // Smartdata DB
+        this.smartdataDb = new plugins.smartdata.SmartdataDb(this.mongoDescriptor);
+        await this.smartdataDb.init();
+        CertManager.activeDB = this.smartdataDb;
+        // Pending Map
+        this.interestMap = new plugins.lik.InterestMap((certName) => certName);
+    }
+    /**
+     * retrieves a certificate
+     * @returns the Cert class or null
+     * @param certDomainNameArg the domain Name to retrieve the vcertificate for
+     */
+    async retrieveCertificate(certDomainNameArg) {
+        const existingCertificate = await Cert.getInstance({
+            domainName: certDomainNameArg,
+        });
+        if (existingCertificate) {
+            return existingCertificate;
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * stores the certificate
+     * @param optionsArg
+     */
+    async storeCertificate(optionsArg) {
+        const cert = new Cert(optionsArg);
+        await cert.save();
+        const interest = this.interestMap.findInterest(cert.domainName);
+        if (interest) {
+            interest.fullfillInterest(cert);
+            interest.markLost();
+        }
+    }
+    async deleteCertificate(certDomainNameArg) {
+        const cert = await Cert.getInstance({
+            domainName: certDomainNameArg,
+        });
+        await cert.delete();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhY21lLmNsYXNzZXMuY2VydG1hbmFnZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGFjbWUuY2xhc3Nlcy5jZXJ0bWFuYWdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHdCQUF3QixDQUFDO0FBQ2xELE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNuRCxPQUEwQixrQ0FBa0MsQ0FBQztBQUU3RCxPQUE0Qix1QkFBdUIsQ0FBQztBQUVwRCxNQUFNLE9BQU8sV0FBVztJQWN0QixZQUNFLFlBQXVCLEVBQ3ZCLFVBRUM7UUFFRCxJQUFJLENBQUMsZUFBZSxHQUFHLFVBQVUsQ0FBQyxlQUFlLENBQUM7SUFDcEQsQ0FBQztJQUVNLEtBQUssQ0FBQyxJQUFJO1FBQ2YsZUFBZTtRQUNmLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxPQUFPLENBQUMsU0FBUyxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUM7UUFDM0UsTUFBTSxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksRUFBRSxDQUFDO1FBQzlCLFdBQVcsQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQztRQUV4QyxjQUFjO1FBQ2QsSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLE9BQU8sQ0FBQyxHQUFHLENBQUMsV0FBVyxDQUFDLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUN6RSxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNJLEtBQUssQ0FBQyxtQkFBbUIsQ0FBQyxpQkFBeUI7UUFDeEQsTUFBTSxtQkFBbUIsR0FBUyxNQUFNLElBQUksQ0FBQyxXQUFXLENBQU87WUFDN0QsVUFBVSxFQUFFLGlCQUFpQjtTQUM5QixDQUFDLENBQUM7UUFFSCxJQUFJLG1CQUFtQixFQUFFO1lBQ3ZCLE9BQU8sbUJBQW1CLENBQUM7U0FDNUI7YUFBTTtZQUNMLE9BQU8sSUFBSSxDQUFDO1NBQ2I7SUFDSCxDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksS0FBSyxDQUFDLGdCQUFnQixDQUFDLFVBQXlDO1FBQ3JFLE1BQU0sSUFBSSxHQUFHLElBQUksSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ2xDLE1BQU0sSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ2xCLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUNoRSxJQUFJLFFBQVEsRUFBRTtZQUNaLFFBQVEsQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUNoQyxRQUFRLENBQUMsUUFBUSxFQUFFLENBQUM7U0FDckI7SUFDSCxDQUFDO0lBRU0sS0FBSyxDQUFDLGlCQUFpQixDQUFDLGlCQUF5QjtRQUN0RCxNQUFNLElBQUksR0FBUyxNQUFNLElBQUksQ0FBQyxXQUFXLENBQU87WUFDOUMsVUFBVSxFQUFFLGlCQUFpQjtTQUM5QixDQUFDLENBQUM7UUFDSCxNQUFNLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQztJQUN0QixDQUFDO0NBQ0YifQ==

package/dist_ts/smartacme.classes.certmatcher.d.ts

@@ -0,0 +1,11 @@
+/**
+ * certmatcher is responsible for matching certificates
+ */
+export declare class CertMatcher {
+    /**
+     * creates a domainName for the certificate that will include the broadest scope
+     * for wild card certificates
+     * @param domainNameArg the domainNameArg to create the scope from
+     */
+    getCertificateDomainNameByDomainName(domainNameArg: string): string;
+}

package/dist_ts/smartacme.classes.certmatcher.js

@@ -0,0 +1,19 @@
+import * as plugins from './smartacme.plugins.js';
+import './interfaces/index.js';
+/**
+ * certmatcher is responsible for matching certificates
+ */
+export class CertMatcher {
+    /**
+     * creates a domainName for the certificate that will include the broadest scope
+     * for wild card certificates
+     * @param domainNameArg the domainNameArg to create the scope from
+     */
+    getCertificateDomainNameByDomainName(domainNameArg) {
+        const originalDomain = new plugins.smartstring.Domain(domainNameArg);
+        if (!originalDomain.level4) {
+            return `${originalDomain.level2}.${originalDomain.level1}`;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhY21lLmNsYXNzZXMuY2VydG1hdGNoZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGFjbWUuY2xhc3Nlcy5jZXJ0bWF0Y2hlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHdCQUF3QixDQUFDO0FBQ2xELE9BQTRCLHVCQUF1QixDQUFDO0FBRXBEOztHQUVHO0FBQ0gsTUFBTSxPQUFPLFdBQVc7SUFDdEI7Ozs7T0FJRztJQUNJLG9DQUFvQyxDQUFDLGFBQXFCO1FBQy9ELE1BQU0sY0FBYyxHQUFHLElBQUksT0FBTyxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDckUsSUFBSSxDQUFDLGNBQWMsQ0FBQyxNQUFNLEVBQUU7WUFDMUIsT0FBTyxHQUFHLGNBQWMsQ0FBQyxNQUFNLElBQUksY0FBYyxDQUFDLE1BQU0sRUFBRSxDQUFDO1NBQzVEO0lBQ0gsQ0FBQztDQUNGIn0=

package/dist_ts/smartacme.classes.smartacme.d.ts

@@ -0,0 +1,58 @@
+import * as plugins from './smartacme.plugins.js';
+import { Cert } from './smartacme.classes.cert.js';
+/**
+ * the options for the class @see SmartAcme
+ */
+export interface ISmartAcmeOptions {
+    accountPrivateKey?: string;
+    accountEmail: string;
+    mongoDescriptor: plugins.smartdata.IMongoDescriptor;
+    setChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
+    removeChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
+    environment: 'production' | 'integration';
+}
+/**
+ * class SmartAcme
+ * can be used for setting up communication with an ACME authority
+ *
+ * ```ts
+ * const mySmartAcmeInstance = new SmartAcme({
+ *  // see ISmartAcmeOptions for options
+ * })
+ * ```
+ */
+export declare class SmartAcme {
+    private options;
+    private client;
+    private smartdns;
+    logger: plugins.smartlog.ConsoleLog;
+    private privateKey;
+    private setChallenge;
+    private removeChallenge;
+    private certmanager;
+    private certmatcher;
+    constructor(optionsArg: ISmartAcmeOptions);
+    /**
+     * inits the instance
+     * ```ts
+     * await myCloudlyInstance.init() // does not support options
+     * ```
+     */
+    init(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * gets a certificate
+     * it runs through the following steps
+     *
+     * * look in the database
+     * * if in the database and still valid return it
+     * * if not in the database announce it
+     * * then get it from letsencrypt
+     * * store it
+     * * remove it from the pending map (which it go onto by announcing it)
+     * * retrieve it from the databse and return it
+     *
+     * @param domainArg
+     */
+    getCertificateForDomain(domainArg: string): Promise<Cert>;
+}

package/dist_ts/smartacme.classes.smartacme.js

@@ -0,0 +1,164 @@
+import * as plugins from './smartacme.plugins.js';
+import './smartacme.classes.cert.js';
+import { CertManager } from './smartacme.classes.certmanager.js';
+import { CertMatcher } from './smartacme.classes.certmatcher.js';
+/**
+ * class SmartAcme
+ * can be used for setting up communication with an ACME authority
+ *
+ * ```ts
+ * const mySmartAcmeInstance = new SmartAcme({
+ *  // see ISmartAcmeOptions for options
+ * })
+ * ```
+ */
+export class SmartAcme {
+    constructor(optionsArg) {
+        this.smartdns = new plugins.smartdns.Smartdns({});
+        this.options = optionsArg;
+        this.logger = new plugins.smartlog.ConsoleLog();
+    }
+    /**
+     * inits the instance
+     * ```ts
+     * await myCloudlyInstance.init() // does not support options
+     * ```
+     */
+    async init() {
+        this.privateKey =
+            this.options.accountPrivateKey || (await plugins.acme.forge.createPrivateKey()).toString();
+        this.setChallenge = this.options.setChallenge;
+        this.removeChallenge = this.options.removeChallenge;
+        // CertMangaer
+        this.certmanager = new CertManager(this, {
+            mongoDescriptor: this.options.mongoDescriptor,
+        });
+        await this.certmanager.init();
+        // CertMatcher
+        this.certmatcher = new CertMatcher();
+        // ACME Client
+        this.client = new plugins.acme.Client({
+            directoryUrl: (() => {
+                if (this.options.environment === 'production') {
+                    return plugins.acme.directory.letsencrypt.production;
+                }
+                else {
+                    return plugins.acme.directory.letsencrypt.staging;
+                }
+            })(),
+            accountKey: this.privateKey,
+        });
+        /* Register account */
+        await this.client.createAccount({
+            termsOfServiceAgreed: true,
+            contact: [`mailto:${this.options.accountEmail}`],
+        });
+    }
+    async stop() {
+        await this.certmanager.smartdataDb.close();
+    }
+    /**
+     * gets a certificate
+     * it runs through the following steps
+     *
+     * * look in the database
+     * * if in the database and still valid return it
+     * * if not in the database announce it
+     * * then get it from letsencrypt
+     * * store it
+     * * remove it from the pending map (which it go onto by announcing it)
+     * * retrieve it from the databse and return it
+     *
+     * @param domainArg
+     */
+    async getCertificateForDomain(domainArg) {
+        const certDomainName = this.certmatcher.getCertificateDomainNameByDomainName(domainArg);
+        const retrievedCertificate = await this.certmanager.retrieveCertificate(certDomainName);
+        if (!retrievedCertificate &&
+            (await this.certmanager.interestMap.checkInterest(certDomainName))) {
+            const existingCertificateInterest = this.certmanager.interestMap.findInterest(certDomainName);
+            const certificate = existingCertificateInterest.interestFullfilled;
+            return certificate;
+        }
+        else if (retrievedCertificate && !retrievedCertificate.shouldBeRenewed()) {
+            return retrievedCertificate;
+        }
+        else if (retrievedCertificate && retrievedCertificate.shouldBeRenewed()) {
+            await retrievedCertificate.delete();
+        }
+        // lets make sure others get the same interest
+        const currentDomainInterst = await this.certmanager.interestMap.addInterest(certDomainName);
+        /* Place new order */
+        const order = await this.client.createOrder({
+            identifiers: [
+                { type: 'dns', value: certDomainName },
+                { type: 'dns', value: `*.${certDomainName}` },
+            ],
+        });
+        /* Get authorizations and select challenges */
+        const authorizations = await this.client.getAuthorizations(order);
+        for (const authz of authorizations) {
+            console.log(authz);
+            const fullHostName = `_acme-challenge.${authz.identifier.value}`;
+            const dnsChallenge = authz.challenges.find((challengeArg) => {
+                return challengeArg.type === 'dns-01';
+            });
+            // process.exit(1);
+            const keyAuthorization = await this.client.getChallengeKeyAuthorization(dnsChallenge);
+            try {
+                /* Satisfy challenge */
+                await this.setChallenge({
+                    hostName: fullHostName,
+                    challenge: keyAuthorization,
+                });
+                await plugins.smartdelay.delayFor(30000);
+                await this.smartdns.checkUntilAvailable(fullHostName, 'TXT', keyAuthorization, 100, 5000);
+                console.log('Cool down an extra 60 second for region availability');
+                await plugins.smartdelay.delayFor(60000);
+                /* Verify that challenge is satisfied */
+                await this.client.verifyChallenge(authz, dnsChallenge);
+                /* Notify ACME provider that challenge is satisfied */
+                await this.client.completeChallenge(dnsChallenge);
+                /* Wait for ACME provider to respond with valid status */
+                await this.client.waitForValidStatus(dnsChallenge);
+            }
+            finally {
+                /* Clean up challenge response */
+                try {
+                    await this.removeChallenge({
+                        hostName: fullHostName,
+                        challenge: keyAuthorization,
+                    });
+                }
+                catch (e) {
+                    console.log(e);
+                }
+            }
+        }
+        /* Finalize order */
+        const [key, csr] = await plugins.acme.forge.createCsr({
+            commonName: `*.${certDomainName}`,
+            altNames: [certDomainName],
+        });
+        await this.client.finalizeOrder(order, csr);
+        const cert = await this.client.getCertificate(order);
+        /* Done */
+        await this.certmanager.storeCertificate({
+            id: plugins.smartunique.shortId(),
+            domainName: certDomainName,
+            privateKey: key.toString(),
+            publicKey: cert.toString(),
+            csr: csr.toString(),
+            created: Date.now(),
+            validUntil: Date.now() +
+                plugins.smarttime.getMilliSecondsFromUnits({
+                    days: 90,
+                }),
+        });
+        const newCertificate = await this.certmanager.retrieveCertificate(certDomainName);
+        currentDomainInterst.fullfillInterest(newCertificate);
+        currentDomainInterst.destroy();
+        return newCertificate;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartacme.plugins.d.ts

@@ -0,0 +1,16 @@
+import * as lik from '@pushrocks/lik';
+import * as smartdata from '@pushrocks/smartdata';
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartdns from '@pushrocks/smartdns';
+import * as smartexpress from '@pushrocks/smartexpress';
+import * as smartlog from '@pushrocks/smartlog';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrequest from '@pushrocks/smartrequest';
+import * as smartunique from '@pushrocks/smartunique';
+import * as smartstring from '@pushrocks/smartstring';
+import * as smarttime from '@pushrocks/smarttime';
+export { lik, smartdata, smartdelay, smartdns, smartexpress, smartlog, smartpromise, smartrequest, smartunique, smartstring, smarttime, };
+import * as tsclass from '@tsclass/tsclass';
+export { tsclass };
+import * as acme from 'acme-client';
+export { acme };

package/dist_ts/smartacme.plugins.js

@@ -0,0 +1,20 @@
+// @pushrocks scope
+import * as lik from '@pushrocks/lik';
+import * as smartdata from '@pushrocks/smartdata';
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartdns from '@pushrocks/smartdns';
+import * as smartexpress from '@pushrocks/smartexpress';
+import * as smartlog from '@pushrocks/smartlog';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrequest from '@pushrocks/smartrequest';
+import * as smartunique from '@pushrocks/smartunique';
+import * as smartstring from '@pushrocks/smartstring';
+import * as smarttime from '@pushrocks/smarttime';
+export { lik, smartdata, smartdelay, smartdns, smartexpress, smartlog, smartpromise, smartrequest, smartunique, smartstring, smarttime, };
+// @tsclass scope
+import * as tsclass from '@tsclass/tsclass';
+export { tsclass };
+// third party scope
+import * as acme from 'acme-client';
+export { acme };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhY21lLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGFjbWUucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxtQkFBbUI7QUFDbkIsT0FBTyxLQUFLLEdBQUcsTUFBTSxnQkFBZ0IsQ0FBQztBQUN0QyxPQUFPLEtBQUssU0FBUyxNQUFNLHNCQUFzQixDQUFDO0FBQ2xELE9BQU8sS0FBSyxVQUFVLE1BQU0sdUJBQXVCLENBQUM7QUFDcEQsT0FBTyxLQUFLLFFBQVEsTUFBTSxxQkFBcUIsQ0FBQztBQUNoRCxPQUFPLEtBQUssWUFBWSxNQUFNLHlCQUF5QixDQUFDO0FBQ3hELE9BQU8sS0FBSyxRQUFRLE1BQU0scUJBQXFCLENBQUM7QUFDaEQsT0FBTyxLQUFLLFlBQVksTUFBTSx5QkFBeUIsQ0FBQztBQUN4RCxPQUFPLEtBQUssWUFBWSxNQUFNLHlCQUF5QixDQUFDO0FBQ3hELE9BQU8sS0FBSyxXQUFXLE1BQU0sd0JBQXdCLENBQUM7QUFDdEQsT0FBTyxLQUFLLFdBQVcsTUFBTSx3QkFBd0IsQ0FBQztBQUN0RCxPQUFPLEtBQUssU0FBUyxNQUFNLHNCQUFzQixDQUFDO0FBRWxELE9BQU8sRUFDTCxHQUFHLEVBQ0gsU0FBUyxFQUNULFVBQVUsRUFDVixRQUFRLEVBQ1IsWUFBWSxFQUNaLFFBQVEsRUFDUixZQUFZLEVBQ1osWUFBWSxFQUNaLFdBQVcsRUFDWCxXQUFXLEVBQ1gsU0FBUyxHQUNWLENBQUM7QUFFRixpQkFBaUI7QUFDakIsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUU1QyxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFFbkIsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sYUFBYSxDQUFDO0FBRXBDLE9BQU8sRUFBRSxJQUFJLEVBQUUsQ0FBQyJ9

package/npmextra.json

@@ -0,0 +1,18 @@
+{
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "smartacme",
+      "shortDescription": "acme with an easy yet powerful interface in TypeScript",
+      "npmPackagename": "@pushrocks/smartacme",
+      "license": "MIT",
+      "projectDomain": "push.rocks"
+    }
+  },
+  "npmci": {
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public"
+  }
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@push.rocks/smartacme",
+  "version": "4.0.3",
+  "private": false,
+  "description": "acme with an easy yet powerful interface in TypeScript",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "test": "(tstest test/)",
+    "build": "(tsbuild --web --allowimplicitany)"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@gitlab.com/umbrellazone/smartacme.git"
+  },
+  "keywords": [
+    "TypeScript",
+    "acme",
+    "letsencrypt"
+  ],
+  "author": "Lossless GmbH",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://gitlab.com/umbrellazone/smartacme/issues"
+  },
+  "homepage": "https://gitlab.com/umbrellazone/smartacme#README",
+  "dependencies": {
+    "@pushrocks/lik": "^6.0.0",
+    "@pushrocks/smartdata": "^5.0.8",
+    "@pushrocks/smartdelay": "^2.0.13",
+    "@pushrocks/smartdns": "^5.0.2",
+    "@pushrocks/smartexpress": "^4.0.21",
+    "@pushrocks/smartlog": "^3.0.1",
+    "@pushrocks/smartpromise": "^3.1.7",
+    "@pushrocks/smartrequest": "^2.0.11",
+    "@pushrocks/smartstring": "^4.0.5",
+    "@pushrocks/smarttime": "^4.0.0",
+    "@pushrocks/smartunique": "^3.0.3",
+    "@tsclass/tsclass": "^4.0.21",
+    "acme-client": "^4.2.5"
+  },
+  "devDependencies": {
+    "@gitzone/tsbuild": "^2.1.65",
+    "@gitzone/tsrun": "^1.2.37",
+    "@gitzone/tstest": "^1.0.73",
+    "@mojoio/cloudflare": "^6.0.1",
+    "@pushrocks/qenv": "^5.0.2",
+    "@pushrocks/tapbundle": "^5.0.4",
+    "@types/node": "^18.7.23"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ]
+}

package/readme.md

@@ -0,0 +1,66 @@
+# @pushrocks/smartacme
+acme with an easy yet powerful interface in TypeScript
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartacme)
+* [gitlab.com (source)](https://gitlab.com/pushrocks/smartacme)
+* [github.com (source mirror)](https://github.com/pushrocks/smartacme)
+* [docs (typedoc)](https://pushrocks.gitlab.io/smartacme/)
+
+## Status for master
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/smartacme/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/smartacme/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/smartacme)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/smartacme)](https://lossless.cloud)
+TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
+node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@pushrocks/smartacme)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/smartacme)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/smartacme)](https://lossless.cloud)
+Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
+
+## Usage
+
+Use TypeScript for best in class instellisense.
+
+```javascript
+import { SmartAcme } from 'smartacme';
+
+const run = async () => {
+  smartAcmeInstance = new smartacme.SmartAcme({
+    accountEmail: 'domains@lossless.org',
+    accountPrivateKey: null,
+    mongoDescriptor: {
+      mongoDbName: testQenv.getEnvVarRequired('MONGODB_DATABASE'),
+      mongoDbPass: testQenv.getEnvVarRequired('MONGODB_PASSWORD'),
+      mongoDbUrl: testQenv.getEnvVarRequired('MONGODB_URL'),
+    },
+    removeChallenge: async (dnsChallenge) => {
+      // somehow provide a function that is able to remove the dns challenge
+    },
+    setChallenge: async (dnsChallenge) => {
+      // somehow provide a function that is able to the dns challenge
+    },
+    environment: 'integration',
+  });
+  await smartAcmeInstance.init();
+
+  // myCert has properties for public/private keys and csr ;)
+  const myCert = await smartAcmeInstance.getCertificateForDomain('bleu.de');
+};
+```
+
+## Contribution
+
+We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+
+For further information read the linked docs at the top of this readme.
+
+> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+
+[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

package/ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@pushrocks/smartacme',
+  version: '4.0.3',
+  description: 'acme with an easy yet powerful interface in TypeScript'
+}

package/ts/index.ts

@@ -0,0 +1 @@
+export * from './smartacme.classes.smartacme.js';

package/ts/interfaces/accountdata.ts

@@ -0,0 +1,8 @@
+export interface IAccountData {
+  id: number;
+  key: { kty: 'RSA'; n: string; e: string; kid: string };
+  contact: string[];
+  initialIp: string;
+  createdAt: string;
+  status: string;
+}

package/ts/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './accountdata.js';

package/ts/smartacme.classes.cert.ts

@@ -0,0 +1,62 @@
+import * as plugins from './smartacme.plugins.js';
+
+import * as interfaces from './interfaces/index.js';
+
+import { CertManager } from './smartacme.classes.certmanager.js';
+
+import { Collection, svDb, unI } from '@pushrocks/smartdata';
+
+@plugins.smartdata.Collection(() => {
+  return CertManager.activeDB;
+})
+export class Cert extends plugins.smartdata.SmartDataDbDoc<Cert, plugins.tsclass.network.ICert>
+  implements plugins.tsclass.network.ICert {
+  @unI()
+  public id: string;
+
+  @svDb()
+  public domainName: string;
+
+  @svDb()
+  public created: number;
+
+  @svDb()
+  public privateKey: string;
+
+  @svDb()
+  public publicKey: string;
+
+  @svDb()
+  public csr: string;
+
+  @svDb()
+  public validUntil: number;
+
+  public isStillValid(): boolean {
+    return this.validUntil >= Date.now();
+  }
+
+  public shouldBeRenewed(): boolean {
+    const shouldBeValidAtLeastUntil =
+      Date.now() +
+      plugins.smarttime.getMilliSecondsFromUnits({
+        days: 10,
+      });
+    return !(this.validUntil >= shouldBeValidAtLeastUntil);
+  }
+
+  public update(certDataArg: plugins.tsclass.network.ICert) {
+    Object.keys(certDataArg).forEach((key) => {
+      this[key] = certDataArg[key];
+    });
+  }
+
+  constructor(optionsArg: plugins.tsclass.network.ICert) {
+    super();
+    if (optionsArg) {
+      Object.keys(optionsArg).forEach((key) => {
+        this[key] = optionsArg[key];
+      });
+    }
+  }
+}

package/ts/smartacme.classes.certmanager.ts

@@ -0,0 +1,77 @@
+import * as plugins from './smartacme.plugins.js';
+import { Cert } from './smartacme.classes.cert.js';
+import { SmartAcme } from './smartacme.classes.smartacme.js';
+
+import * as interfaces from './interfaces/index.js';
+
+export class CertManager {
+  // =========
+  // STATIC
+  // =========
+  public static activeDB: plugins.smartdata.SmartdataDb;
+
+  // =========
+  // INSTANCE
+  // =========
+  private mongoDescriptor: plugins.smartdata.IMongoDescriptor;
+  public smartdataDb: plugins.smartdata.SmartdataDb;
+
+  public interestMap: plugins.lik.InterestMap<string, Cert>;
+
+  constructor(
+    smartAcmeArg: SmartAcme,
+    optionsArg: {
+      mongoDescriptor: plugins.smartdata.IMongoDescriptor;
+    }
+  ) {
+    this.mongoDescriptor = optionsArg.mongoDescriptor;
+  }
+
+  public async init() {
+    // Smartdata DB
+    this.smartdataDb = new plugins.smartdata.SmartdataDb(this.mongoDescriptor);
+    await this.smartdataDb.init();
+    CertManager.activeDB = this.smartdataDb;
+
+    // Pending Map
+    this.interestMap = new plugins.lik.InterestMap((certName) => certName);
+  }
+
+  /**
+   * retrieves a certificate
+   * @returns the Cert class or null
+   * @param certDomainNameArg the domain Name to retrieve the vcertificate for
+   */
+  public async retrieveCertificate(certDomainNameArg: string): Promise<Cert> {
+    const existingCertificate: Cert = await Cert.getInstance<Cert>({
+      domainName: certDomainNameArg,
+    });
+
+    if (existingCertificate) {
+      return existingCertificate;
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * stores the certificate
+   * @param optionsArg
+   */
+  public async storeCertificate(optionsArg: plugins.tsclass.network.ICert) {
+    const cert = new Cert(optionsArg);
+    await cert.save();
+    const interest = this.interestMap.findInterest(cert.domainName);
+    if (interest) {
+      interest.fullfillInterest(cert);
+      interest.markLost();
+    }
+  }
+
+  public async deleteCertificate(certDomainNameArg: string) {
+    const cert: Cert = await Cert.getInstance<Cert>({
+      domainName: certDomainNameArg,
+    });
+    await cert.delete();
+  }
+}

package/ts/smartacme.classes.certmatcher.ts

@@ -0,0 +1,19 @@
+import * as plugins from './smartacme.plugins.js';
+import * as interfaces from './interfaces/index.js';
+
+/**
+ * certmatcher is responsible for matching certificates
+ */
+export class CertMatcher {
+  /**
+   * creates a domainName for the certificate that will include the broadest scope
+   * for wild card certificates
+   * @param domainNameArg the domainNameArg to create the scope from
+   */
+  public getCertificateDomainNameByDomainName(domainNameArg: string): string {
+    const originalDomain = new plugins.smartstring.Domain(domainNameArg);
+    if (!originalDomain.level4) {
+      return `${originalDomain.level2}.${originalDomain.level1}`;
+    }
+  }
+}

package/ts/smartacme.classes.smartacme.ts

@@ -0,0 +1,212 @@
+import * as plugins from './smartacme.plugins.js';
+import { Cert } from './smartacme.classes.cert.js';
+import { CertManager } from './smartacme.classes.certmanager.js';
+import { CertMatcher } from './smartacme.classes.certmatcher.js';
+
+/**
+ * the options for the class @see SmartAcme
+ */
+export interface ISmartAcmeOptions {
+  accountPrivateKey?: string;
+  accountEmail: string;
+  mongoDescriptor: plugins.smartdata.IMongoDescriptor;
+  setChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
+  removeChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
+  environment: 'production' | 'integration';
+}
+
+/**
+ * class SmartAcme
+ * can be used for setting up communication with an ACME authority
+ *
+ * ```ts
+ * const mySmartAcmeInstance = new SmartAcme({
+ *  // see ISmartAcmeOptions for options
+ * })
+ * ```
+ */
+export class SmartAcme {
+  private options: ISmartAcmeOptions;
+
+  // the acme client
+  private client: any;
+  private smartdns = new plugins.smartdns.Smartdns({});
+  public logger: plugins.smartlog.ConsoleLog;
+
+  // the account private key
+  private privateKey: string;
+
+  // challenge fullfillment
+  private setChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
+  private removeChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
+
+  // certmanager
+  private certmanager: CertManager;
+  private certmatcher: CertMatcher;
+
+  constructor(optionsArg: ISmartAcmeOptions) {
+    this.options = optionsArg;
+    this.logger = new plugins.smartlog.ConsoleLog();
+  }
+
+  /**
+   * inits the instance
+   * ```ts
+   * await myCloudlyInstance.init() // does not support options
+   * ```
+   */
+  public async init() {
+    this.privateKey =
+      this.options.accountPrivateKey || (await plugins.acme.forge.createPrivateKey()).toString();
+    this.setChallenge = this.options.setChallenge;
+    this.removeChallenge = this.options.removeChallenge;
+
+    // CertMangaer
+    this.certmanager = new CertManager(this, {
+      mongoDescriptor: this.options.mongoDescriptor,
+    });
+    await this.certmanager.init();
+
+    // CertMatcher
+    this.certmatcher = new CertMatcher();
+
+    // ACME Client
+    this.client = new plugins.acme.Client({
+      directoryUrl: (() => {
+        if (this.options.environment === 'production') {
+          return plugins.acme.directory.letsencrypt.production;
+        } else {
+          return plugins.acme.directory.letsencrypt.staging;
+        }
+      })(),
+      accountKey: this.privateKey,
+    });
+
+    /* Register account */
+    await this.client.createAccount({
+      termsOfServiceAgreed: true,
+      contact: [`mailto:${this.options.accountEmail}`],
+    });
+  }
+
+  public async stop() {
+    await this.certmanager.smartdataDb.close();
+  }
+
+  /**
+   * gets a certificate
+   * it runs through the following steps
+   *
+   * * look in the database
+   * * if in the database and still valid return it
+   * * if not in the database announce it
+   * * then get it from letsencrypt
+   * * store it
+   * * remove it from the pending map (which it go onto by announcing it)
+   * * retrieve it from the databse and return it
+   *
+   * @param domainArg
+   */
+  public async getCertificateForDomain(domainArg: string): Promise<Cert> {
+    const certDomainName = this.certmatcher.getCertificateDomainNameByDomainName(domainArg);
+    const retrievedCertificate = await this.certmanager.retrieveCertificate(certDomainName);
+
+    if (
+      !retrievedCertificate &&
+      (await this.certmanager.interestMap.checkInterest(certDomainName))
+    ) {
+      const existingCertificateInterest = this.certmanager.interestMap.findInterest(certDomainName);
+      const certificate = existingCertificateInterest.interestFullfilled;
+      return certificate;
+    } else if (retrievedCertificate && !retrievedCertificate.shouldBeRenewed()) {
+      return retrievedCertificate;
+    } else if (retrievedCertificate && retrievedCertificate.shouldBeRenewed()) {
+      await retrievedCertificate.delete();
+    }
+
+    // lets make sure others get the same interest
+    const currentDomainInterst = await this.certmanager.interestMap.addInterest(certDomainName);
+
+    /* Place new order */
+    const order = await this.client.createOrder({
+      identifiers: [
+        { type: 'dns', value: certDomainName },
+        { type: 'dns', value: `*.${certDomainName}` },
+      ],
+    });
+
+    /* Get authorizations and select challenges */
+    const authorizations = await this.client.getAuthorizations(order);
+
+    for (const authz of authorizations) {
+      console.log(authz);
+      const fullHostName: string = `_acme-challenge.${authz.identifier.value}`;
+      const dnsChallenge: string = authz.challenges.find((challengeArg) => {
+        return challengeArg.type === 'dns-01';
+      });
+      // process.exit(1);
+      const keyAuthorization: string = await this.client.getChallengeKeyAuthorization(dnsChallenge);
+
+      try {
+        /* Satisfy challenge */
+        await this.setChallenge({
+          hostName: fullHostName,
+          challenge: keyAuthorization,
+        });
+        await plugins.smartdelay.delayFor(30000);
+        await this.smartdns.checkUntilAvailable(fullHostName, 'TXT', keyAuthorization, 100, 5000);
+        console.log('Cool down an extra 60 second for region availability');
+        await plugins.smartdelay.delayFor(60000);
+
+        /* Verify that challenge is satisfied */
+        await this.client.verifyChallenge(authz, dnsChallenge);
+
+        /* Notify ACME provider that challenge is satisfied */
+        await this.client.completeChallenge(dnsChallenge);
+
+        /* Wait for ACME provider to respond with valid status */
+        await this.client.waitForValidStatus(dnsChallenge);
+      } finally {
+        /* Clean up challenge response */
+        try {
+          await this.removeChallenge({
+            hostName: fullHostName,
+            challenge: keyAuthorization,
+          });
+        } catch (e) {
+          console.log(e);
+        }
+      }
+    }
+
+    /* Finalize order */
+    const [key, csr] = await plugins.acme.forge.createCsr({
+      commonName: `*.${certDomainName}`,
+      altNames: [certDomainName],
+    });
+
+    await this.client.finalizeOrder(order, csr);
+    const cert = await this.client.getCertificate(order);
+
+    /* Done */
+
+    await this.certmanager.storeCertificate({
+      id: plugins.smartunique.shortId(),
+      domainName: certDomainName,
+      privateKey: key.toString(),
+      publicKey: cert.toString(),
+      csr: csr.toString(),
+      created: Date.now(),
+      validUntil:
+        Date.now() +
+        plugins.smarttime.getMilliSecondsFromUnits({
+          days: 90,
+        }),
+    });
+
+    const newCertificate = await this.certmanager.retrieveCertificate(certDomainName);
+    currentDomainInterst.fullfillInterest(newCertificate);
+    currentDomainInterst.destroy();
+    return newCertificate;
+  }
+}

package/ts/smartacme.plugins.ts

@@ -0,0 +1,36 @@
+// @pushrocks scope
+import * as lik from '@pushrocks/lik';
+import * as smartdata from '@pushrocks/smartdata';
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartdns from '@pushrocks/smartdns';
+import * as smartexpress from '@pushrocks/smartexpress';
+import * as smartlog from '@pushrocks/smartlog';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrequest from '@pushrocks/smartrequest';
+import * as smartunique from '@pushrocks/smartunique';
+import * as smartstring from '@pushrocks/smartstring';
+import * as smarttime from '@pushrocks/smarttime';
+
+export {
+  lik,
+  smartdata,
+  smartdelay,
+  smartdns,
+  smartexpress,
+  smartlog,
+  smartpromise,
+  smartrequest,
+  smartunique,
+  smartstring,
+  smarttime,
+};
+
+// @tsclass scope
+import * as tsclass from '@tsclass/tsclass';
+
+export { tsclass };
+
+// third party scope
+import * as acme from 'acme-client';
+
+export { acme };