@peerbit/crypto 2.3.13 → 2.4.1-e209d2e

package/dist/src/encryption.js

@@ -1,13 +1,37 @@
-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 __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
 };
-var DecryptedThing_1, CipherWithNonce_1, K_1, PublicKeyEnvelope_1, HashedKeyEnvelope_1, EncryptedThing_1;
 import { deserialize, field, fixedArray, serialize, variant, vec, } from "@dao-xyz/borsh";
 import sodium from "libsodium-wrappers";
 import { equals as uequals } from "uint8arrays";
@@ -18,8 +42,9 @@ import { randomBytes } from "./random.js";
 import { X25519Keypair, X25519PublicKey, X25519SecretKey } from "./x25519.js";
 export * from "./errors.js";
 export const equals = (array1, array2) => {
-    if (!!array1 !== !!array2)
+    if (!!array1 !== !!array2) {
         return false;
+    }
     if (!array1 || !array2) {
         return false;
     }
@@ -124,327 +149,424 @@ export const createDecrypterFromKeyResolver = (keyResolver) => {
     };
 };
 const NONCE_LENGTH = 24;
-let MaybeEncrypted = class MaybeEncrypted {
-    /**
-     * Will throw error if not decrypted
-     */
-    get decrypted() {
-        throw new Error("Not implented");
-    }
-    decrypt(provider) {
-        throw new Error("Not implemented");
-    }
-    equals(other) {
-        throw new Error("Not implemented");
-    }
-    /**
-     * Clear cached data
-     */
-    clear() {
-        throw new Error("Not implemented");
-    }
-};
-MaybeEncrypted = __decorate([
-    variant(0)
-], MaybeEncrypted);
-export { MaybeEncrypted };
-let DecryptedThing = DecryptedThing_1 = class DecryptedThing extends MaybeEncrypted {
-    _data;
-    constructor(props) {
-        super();
-        if (props) {
-            this._data = props.data;
-            this._value = props.value;
+let MaybeEncrypted = (() => {
+    let _classDecorators = [variant(0)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var MaybeEncrypted = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            MaybeEncrypted = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-    }
-    _value;
-    getValue(clazz) {
-        if (this._value) {
-            return this._value;
+        /**
+         * Will throw error if not decrypted
+         */
+        get decrypted() {
+            throw new Error("Not implented");
         }
-        if (!this._data) {
-            throw new Error("Missing data");
+        decrypt(provider) {
+            throw new Error("Not implemented");
         }
-        return deserialize(this._data, clazz);
-    }
-    async encrypt(keypair, parameters) {
-        let provider;
-        let options;
-        if (keypair instanceof X25519Keypair) {
-            provider = createLocalEncryptProvider(keypair);
-            options = {
-                receiverPublicKeys: parameters,
-                type: "publicKey",
-            };
+        equals(other) {
+            throw new Error("Not implemented");
         }
-        else {
-            provider = keypair;
-            options = parameters;
-        }
-        const bytes = serialize(this);
-        const { cipher, envelope, nonce } = await provider(bytes, options);
-        const enc = new EncryptedThing({
-            encrypted: cipher,
-            envelope,
-            nonce,
-        });
-        enc._decrypted = this;
-        return enc;
-    }
-    get decrypted() {
-        return this;
-    }
-    decrypt() {
-        return this;
-    }
-    equals(other) {
-        if (other instanceof DecryptedThing_1) {
-            return equals(this._data, other._data);
+        /**
+         * Clear cached data
+         */
+        clear() {
+            throw new Error("Not implemented");
         }
-        else {
-            return false;
+    };
+    return MaybeEncrypted = _classThis;
+})();
+export { MaybeEncrypted };
+let DecryptedThing = (() => {
+    let _classDecorators = [variant(0)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = MaybeEncrypted;
+    let __data_decorators;
+    let __data_initializers = [];
+    let __data_extraInitializers = [];
+    var DecryptedThing = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __data_decorators = [field({ type: Uint8Array })];
+            __esDecorate(null, null, __data_decorators, { kind: "field", name: "_data", static: false, private: false, access: { has: obj => "_data" in obj, get: obj => obj._data, set: (obj, value) => { obj._data = value; } }, metadata: _metadata }, __data_initializers, __data_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            DecryptedThing = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-    }
-    clear() {
-        this._value = undefined;
-    }
-    get byteLength() {
-        return this._data.byteLength;
-    }
-};
-__decorate([
-    field({ type: Uint8Array }),
-    __metadata("design:type", Uint8Array)
-], DecryptedThing.prototype, "_data", void 0);
-DecryptedThing = DecryptedThing_1 = __decorate([
-    variant(0),
-    __metadata("design:paramtypes", [Object])
-], DecryptedThing);
-export { DecryptedThing };
-let CipherWithNonce = CipherWithNonce_1 = class CipherWithNonce {
-    nonce;
-    cipher;
-    constructor(props) {
-        this.nonce = props.nonce;
-        this.cipher = props.cipher;
-    }
-    equals(other) {
-        if (other instanceof CipherWithNonce_1) {
-            return (equals(this.nonce, other.nonce) && equals(this.cipher, other.cipher));
+        _data = __runInitializers(this, __data_initializers, void 0);
+        constructor(props) {
+            super();
+            if (props) {
+                this._data = props.data;
+                this._value = props.value;
+            }
         }
-        else {
-            return false;
+        _value = __runInitializers(this, __data_extraInitializers);
+        getValue(clazz) {
+            if (this._value) {
+                return this._value;
+            }
+            if (!this._data) {
+                throw new Error("Missing data");
+            }
+            return deserialize(this._data, clazz);
         }
-    }
-};
-__decorate([
-    field({ type: Uint8Array }),
-    __metadata("design:type", Uint8Array)
-], CipherWithNonce.prototype, "nonce", void 0);
-__decorate([
-    field({ type: Uint8Array }),
-    __metadata("design:type", Uint8Array)
-], CipherWithNonce.prototype, "cipher", void 0);
-CipherWithNonce = CipherWithNonce_1 = __decorate([
-    variant(0),
-    __metadata("design:paramtypes", [Object])
-], CipherWithNonce);
-export { CipherWithNonce };
-let K = K_1 = class K {
-    _encryptedKey;
-    _receiverPublicKey;
-    constructor(props) {
-        this._encryptedKey = props.encryptedKey;
-        this._receiverPublicKey = props.receiverPublicKey;
-    }
-    equals(other) {
-        if (other instanceof K_1) {
-            return (this._encryptedKey.equals(other._encryptedKey) &&
-                this._receiverPublicKey.equals(other._receiverPublicKey));
+        async encrypt(keypair, parameters) {
+            let provider;
+            let options;
+            if (keypair instanceof X25519Keypair) {
+                provider = createLocalEncryptProvider(keypair);
+                options = {
+                    receiverPublicKeys: parameters,
+                    type: "publicKey",
+                };
+            }
+            else {
+                provider = keypair;
+                options = parameters;
+            }
+            const bytes = serialize(this);
+            const { cipher, envelope, nonce } = await provider(bytes, options);
+            const enc = new EncryptedThing({
+                encrypted: cipher,
+                envelope,
+                nonce,
+            });
+            enc._decrypted = this;
+            return enc;
         }
-        else {
-            return false;
+        get decrypted() {
+            return this;
         }
-    }
-};
-__decorate([
-    field({ type: CipherWithNonce }),
-    __metadata("design:type", CipherWithNonce)
-], K.prototype, "_encryptedKey", void 0);
-__decorate([
-    field({ type: X25519PublicKey }),
-    __metadata("design:type", X25519PublicKey)
-], K.prototype, "_receiverPublicKey", void 0);
-K = K_1 = __decorate([
-    variant(0),
-    __metadata("design:paramtypes", [Object])
-], K);
-export { K };
-class Envelope {
-}
-let PublicKeyEnvelope = PublicKeyEnvelope_1 = class PublicKeyEnvelope extends Envelope {
-    _senderPublicKey;
-    _ks;
-    constructor(props) {
-        super();
-        this._senderPublicKey = props.senderPublicKey;
-        this._ks = props.ks;
-    }
-    // TODO: should this be comparable to AbstractEnvelope?
-    equals(other) {
-        if (other instanceof PublicKeyEnvelope_1) {
-            if (!this._senderPublicKey.equals(other._senderPublicKey)) {
-                return false;
+        decrypt() {
+            return this;
+        }
+        equals(other) {
+            if (other instanceof DecryptedThing) {
+                return equals(this._data, other._data);
             }
-            if (this._ks.length !== other._ks.length) {
+            else {
                 return false;
             }
-            for (let i = 0; i < this._ks.length; i++) {
-                if (!this._ks[i].equals(other._ks[i])) {
-                    return false;
-                }
+        }
+        clear() {
+            this._value = undefined;
+        }
+        get byteLength() {
+            return this._data.byteLength;
+        }
+    };
+    return DecryptedThing = _classThis;
+})();
+export { DecryptedThing };
+let CipherWithNonce = (() => {
+    let _classDecorators = [variant(0)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _nonce_decorators;
+    let _nonce_initializers = [];
+    let _nonce_extraInitializers = [];
+    let _cipher_decorators;
+    let _cipher_initializers = [];
+    let _cipher_extraInitializers = [];
+    var CipherWithNonce = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _nonce_decorators = [field({ type: Uint8Array })];
+            _cipher_decorators = [field({ type: Uint8Array })];
+            __esDecorate(null, null, _nonce_decorators, { kind: "field", name: "nonce", static: false, private: false, access: { has: obj => "nonce" in obj, get: obj => obj.nonce, set: (obj, value) => { obj.nonce = value; } }, metadata: _metadata }, _nonce_initializers, _nonce_extraInitializers);
+            __esDecorate(null, null, _cipher_decorators, { kind: "field", name: "cipher", static: false, private: false, access: { has: obj => "cipher" in obj, get: obj => obj.cipher, set: (obj, value) => { obj.cipher = value; } }, metadata: _metadata }, _cipher_initializers, _cipher_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            CipherWithNonce = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        nonce = __runInitializers(this, _nonce_initializers, void 0);
+        cipher = (__runInitializers(this, _nonce_extraInitializers), __runInitializers(this, _cipher_initializers, void 0));
+        constructor(props) {
+            __runInitializers(this, _cipher_extraInitializers);
+            this.nonce = props.nonce;
+            this.cipher = props.cipher;
+        }
+        equals(other) {
+            if (other instanceof CipherWithNonce) {
+                return (equals(this.nonce, other.nonce) && equals(this.cipher, other.cipher));
             }
-            return true;
+            else {
+                return false;
+            }
+        }
+    };
+    return CipherWithNonce = _classThis;
+})();
+export { CipherWithNonce };
+let K = (() => {
+    let _classDecorators = [variant(0)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let __encryptedKey_decorators;
+    let __encryptedKey_initializers = [];
+    let __encryptedKey_extraInitializers = [];
+    let __receiverPublicKey_decorators;
+    let __receiverPublicKey_initializers = [];
+    let __receiverPublicKey_extraInitializers = [];
+    var K = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __encryptedKey_decorators = [field({ type: CipherWithNonce })];
+            __receiverPublicKey_decorators = [field({ type: X25519PublicKey })];
+            __esDecorate(null, null, __encryptedKey_decorators, { kind: "field", name: "_encryptedKey", static: false, private: false, access: { has: obj => "_encryptedKey" in obj, get: obj => obj._encryptedKey, set: (obj, value) => { obj._encryptedKey = value; } }, metadata: _metadata }, __encryptedKey_initializers, __encryptedKey_extraInitializers);
+            __esDecorate(null, null, __receiverPublicKey_decorators, { kind: "field", name: "_receiverPublicKey", static: false, private: false, access: { has: obj => "_receiverPublicKey" in obj, get: obj => obj._receiverPublicKey, set: (obj, value) => { obj._receiverPublicKey = value; } }, metadata: _metadata }, __receiverPublicKey_initializers, __receiverPublicKey_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            K = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-        else {
-            return false;
+        _encryptedKey = __runInitializers(this, __encryptedKey_initializers, void 0);
+        _receiverPublicKey = (__runInitializers(this, __encryptedKey_extraInitializers), __runInitializers(this, __receiverPublicKey_initializers, void 0));
+        constructor(props) {
+            __runInitializers(this, __receiverPublicKey_extraInitializers);
+            this._encryptedKey = props.encryptedKey;
+            this._receiverPublicKey = props.receiverPublicKey;
         }
-    }
-};
-__decorate([
-    field({ type: X25519PublicKey }),
-    __metadata("design:type", X25519PublicKey)
-], PublicKeyEnvelope.prototype, "_senderPublicKey", void 0);
-__decorate([
-    field({ type: vec(K) }),
-    __metadata("design:type", Array)
-], PublicKeyEnvelope.prototype, "_ks", void 0);
-PublicKeyEnvelope = PublicKeyEnvelope_1 = __decorate([
-    variant(0),
-    __metadata("design:paramtypes", [Object])
-], PublicKeyEnvelope);
-let HashedKeyEnvelope = HashedKeyEnvelope_1 = class HashedKeyEnvelope extends Envelope {
-    hash;
-    // TODO: Do we need a salt here?
-    constructor(props) {
-        super();
-        this.hash = props.hash;
-    }
-    // TODO: should this be comparable to AbstractEnvelope?
-    equals(other) {
-        if (other instanceof HashedKeyEnvelope_1) {
-            if (!equals(this.hash, other.hash)) {
+        equals(other) {
+            if (other instanceof K) {
+                return (this._encryptedKey.equals(other._encryptedKey) &&
+                    this._receiverPublicKey.equals(other._receiverPublicKey));
+            }
+            else {
                 return false;
             }
-            return true;
         }
-        else {
-            return false;
+    };
+    return K = _classThis;
+})();
+export { K };
+class Envelope {
+}
+let PublicKeyEnvelope = (() => {
+    let _classDecorators = [variant(0)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = Envelope;
+    let __senderPublicKey_decorators;
+    let __senderPublicKey_initializers = [];
+    let __senderPublicKey_extraInitializers = [];
+    let __ks_decorators;
+    let __ks_initializers = [];
+    let __ks_extraInitializers = [];
+    var PublicKeyEnvelope = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __senderPublicKey_decorators = [field({ type: X25519PublicKey })];
+            __ks_decorators = [field({ type: vec(K) })];
+            __esDecorate(null, null, __senderPublicKey_decorators, { kind: "field", name: "_senderPublicKey", static: false, private: false, access: { has: obj => "_senderPublicKey" in obj, get: obj => obj._senderPublicKey, set: (obj, value) => { obj._senderPublicKey = value; } }, metadata: _metadata }, __senderPublicKey_initializers, __senderPublicKey_extraInitializers);
+            __esDecorate(null, null, __ks_decorators, { kind: "field", name: "_ks", static: false, private: false, access: { has: obj => "_ks" in obj, get: obj => obj._ks, set: (obj, value) => { obj._ks = value; } }, metadata: _metadata }, __ks_initializers, __ks_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            PublicKeyEnvelope = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-    }
-};
-__decorate([
-    field({ type: fixedArray("u8", 32) }),
-    __metadata("design:type", Uint8Array)
-], HashedKeyEnvelope.prototype, "hash", void 0);
-HashedKeyEnvelope = HashedKeyEnvelope_1 = __decorate([
-    variant(1),
-    __metadata("design:paramtypes", [Object])
-], HashedKeyEnvelope);
-let EncryptedThing = EncryptedThing_1 = class EncryptedThing extends MaybeEncrypted {
-    _encrypted;
-    _nonce;
-    _keyexchange;
-    constructor(props) {
-        super();
-        this._encrypted = props.encrypted;
-        this._nonce = props.nonce;
-        this._keyexchange = props.envelope;
-    }
-    _decrypted;
-    get decrypted() {
-        if (!this._decrypted) {
-            throw new Error("Entry has not been decrypted, invoke decrypt method before");
+        _senderPublicKey = __runInitializers(this, __senderPublicKey_initializers, void 0);
+        _ks = (__runInitializers(this, __senderPublicKey_extraInitializers), __runInitializers(this, __ks_initializers, void 0));
+        constructor(props) {
+            super();
+            __runInitializers(this, __ks_extraInitializers);
+            this._senderPublicKey = props.senderPublicKey;
+            this._ks = props.ks;
         }
-        return this._decrypted;
-    }
-    async decrypt(providerOrResolver) {
-        let provider;
-        if (typeof providerOrResolver === "function") {
-            provider = providerOrResolver;
-        }
-        else if (providerOrResolver instanceof X25519Keypair) {
-            const resolver = (key) => {
-                if (key instanceof X25519PublicKey) {
-                    if (key.equals(providerOrResolver.publicKey)) {
-                        return providerOrResolver;
+        // TODO: should this be comparable to AbstractEnvelope?
+        equals(other) {
+            if (other instanceof PublicKeyEnvelope) {
+                if (!this._senderPublicKey.equals(other._senderPublicKey)) {
+                    return false;
+                }
+                if (this._ks.length !== other._ks.length) {
+                    return false;
+                }
+                for (let i = 0; i < this._ks.length; i++) {
+                    if (!this._ks[i].equals(other._ks[i])) {
+                        return false;
                     }
                 }
-                throw new Error("Missing keypair");
-            };
-            provider = createDecrypterFromKeyResolver(resolver);
+                return true;
+            }
+            else {
+                return false;
+            }
         }
-        else if (providerOrResolver) {
-            provider = createDecrypterFromKeyResolver(async (key) => {
-                if (key instanceof X25519PublicKey) {
-                    const keypair = await providerOrResolver.exportByKey(key);
-                    return keypair;
+    };
+    return PublicKeyEnvelope = _classThis;
+})();
+let HashedKeyEnvelope = (() => {
+    let _classDecorators = [variant(1)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = Envelope;
+    let _hash_decorators;
+    let _hash_initializers = [];
+    let _hash_extraInitializers = [];
+    var HashedKeyEnvelope = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _hash_decorators = [field({ type: fixedArray("u8", 32) })];
+            __esDecorate(null, null, _hash_decorators, { kind: "field", name: "hash", static: false, private: false, access: { has: obj => "hash" in obj, get: obj => obj.hash, set: (obj, value) => { obj.hash = value; } }, metadata: _metadata }, _hash_initializers, _hash_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            HashedKeyEnvelope = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        hash = __runInitializers(this, _hash_initializers, void 0);
+        // TODO: Do we need a salt here?
+        constructor(props) {
+            super();
+            __runInitializers(this, _hash_extraInitializers);
+            this.hash = props.hash;
+        }
+        // TODO: should this be comparable to AbstractEnvelope?
+        equals(other) {
+            if (other instanceof HashedKeyEnvelope) {
+                if (!equals(this.hash, other.hash)) {
+                    return false;
                 }
-            });
+                return true;
+            }
+            else {
+                return false;
+            }
         }
-        if (this._decrypted) {
-            return this._decrypted;
+    };
+    return HashedKeyEnvelope = _classThis;
+})();
+let EncryptedThing = (() => {
+    let _classDecorators = [variant(1)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = MaybeEncrypted;
+    let __encrypted_decorators;
+    let __encrypted_initializers = [];
+    let __encrypted_extraInitializers = [];
+    let __nonce_decorators;
+    let __nonce_initializers = [];
+    let __nonce_extraInitializers = [];
+    let __keyexchange_decorators;
+    let __keyexchange_initializers = [];
+    let __keyexchange_extraInitializers = [];
+    var EncryptedThing = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __encrypted_decorators = [field({ type: Uint8Array })];
+            __nonce_decorators = [field({ type: Uint8Array })];
+            __keyexchange_decorators = [field({ type: Envelope })];
+            __esDecorate(null, null, __encrypted_decorators, { kind: "field", name: "_encrypted", static: false, private: false, access: { has: obj => "_encrypted" in obj, get: obj => obj._encrypted, set: (obj, value) => { obj._encrypted = value; } }, metadata: _metadata }, __encrypted_initializers, __encrypted_extraInitializers);
+            __esDecorate(null, null, __nonce_decorators, { kind: "field", name: "_nonce", static: false, private: false, access: { has: obj => "_nonce" in obj, get: obj => obj._nonce, set: (obj, value) => { obj._nonce = value; } }, metadata: _metadata }, __nonce_initializers, __nonce_extraInitializers);
+            __esDecorate(null, null, __keyexchange_decorators, { kind: "field", name: "_keyexchange", static: false, private: false, access: { has: obj => "_keyexchange" in obj, get: obj => obj._keyexchange, set: (obj, value) => { obj._keyexchange = value; } }, metadata: _metadata }, __keyexchange_initializers, __keyexchange_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            EncryptedThing = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-        if (!provider) {
-            throw new AccessError("Expecting decryption provider");
+        _encrypted = __runInitializers(this, __encrypted_initializers, void 0);
+        _nonce = (__runInitializers(this, __encrypted_extraInitializers), __runInitializers(this, __nonce_initializers, void 0));
+        _keyexchange = (__runInitializers(this, __nonce_extraInitializers), __runInitializers(this, __keyexchange_initializers, void 0));
+        constructor(props) {
+            super();
+            this._encrypted = props.encrypted;
+            this._nonce = props.nonce;
+            this._keyexchange = props.envelope;
         }
-        const decrypted = await provider(this._encrypted, this._nonce, this._keyexchange);
-        if (decrypted) {
-            const der = deserialize(decrypted, DecryptedThing);
-            this._decrypted = der;
+        _decrypted = __runInitializers(this, __keyexchange_extraInitializers);
+        get decrypted() {
+            if (!this._decrypted) {
+                throw new Error("Entry has not been decrypted, invoke decrypt method before");
+            }
             return this._decrypted;
         }
-        throw new AccessError("Failed to resolve decryption key");
-    }
-    equals(other) {
-        if (other instanceof EncryptedThing_1) {
-            if (!equals(this._encrypted, other._encrypted)) {
-                return false;
+        async decrypt(providerOrResolver) {
+            let provider;
+            if (typeof providerOrResolver === "function") {
+                provider = providerOrResolver;
             }
-            if (!equals(this._nonce, other._nonce)) {
-                return false;
+            else if (providerOrResolver instanceof X25519Keypair) {
+                const resolver = (key) => {
+                    if (key instanceof X25519PublicKey) {
+                        if (key.equals(providerOrResolver.publicKey)) {
+                            return providerOrResolver;
+                        }
+                    }
+                    throw new Error("Missing keypair");
+                };
+                provider = createDecrypterFromKeyResolver(resolver);
+            }
+            else if (providerOrResolver) {
+                provider = createDecrypterFromKeyResolver(async (key) => {
+                    if (key instanceof X25519PublicKey) {
+                        const keypair = await providerOrResolver.exportByKey(key);
+                        return keypair;
+                    }
+                });
+            }
+            if (this._decrypted) {
+                return this._decrypted;
+            }
+            if (!provider) {
+                throw new AccessError("Expecting decryption provider");
+            }
+            const decrypted = await provider(this._encrypted, this._nonce, this._keyexchange);
+            if (decrypted) {
+                const der = deserialize(decrypted, DecryptedThing);
+                this._decrypted = der;
+                return this._decrypted;
             }
-            if (!this._keyexchange.equals(other._keyexchange)) {
+            throw new AccessError("Failed to resolve decryption key");
+        }
+        equals(other) {
+            if (other instanceof EncryptedThing) {
+                if (!equals(this._encrypted, other._encrypted)) {
+                    return false;
+                }
+                if (!equals(this._nonce, other._nonce)) {
+                    return false;
+                }
+                if (!this._keyexchange.equals(other._keyexchange)) {
+                    return false;
+                }
+                return true;
+            }
+            else {
                 return false;
             }
-            return true;
         }
-        else {
-            return false;
+        clear() {
+            this._decrypted = undefined;
         }
-    }
-    clear() {
-        this._decrypted = undefined;
-    }
-    get byteLength() {
-        return this._encrypted.byteLength; // ignore other metdata for now in the size calculation
-    }
-};
-__decorate([
-    field({ type: Uint8Array }),
-    __metadata("design:type", Uint8Array)
-], EncryptedThing.prototype, "_encrypted", void 0);
-__decorate([
-    field({ type: Uint8Array }),
-    __metadata("design:type", Uint8Array)
-], EncryptedThing.prototype, "_nonce", void 0);
-__decorate([
-    field({ type: Envelope }),
-    __metadata("design:type", Object)
-], EncryptedThing.prototype, "_keyexchange", void 0);
-EncryptedThing = EncryptedThing_1 = __decorate([
-    variant(1),
-    __metadata("design:paramtypes", [Object])
-], EncryptedThing);
+        get byteLength() {
+            return this._encrypted.byteLength; // ignore other metdata for now in the size calculation
+        }
+    };
+    return EncryptedThing = _classThis;
+})();
 export { EncryptedThing };
 //# sourceMappingURL=encryption.js.map