@peerbit/log 4.1.11 → 4.2.0

package/dist/src/entry-v0.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 EntryV0_1;
 import { field, fixedArray, option, serialize, variant, vec, } from "@dao-xyz/borsh";
 import {} from "@peerbit/blocks-interface";
 import { AccessError, DecryptedThing, Ed25519PublicKey, MaybeEncrypted, PublicSignKey, SignatureWithKey, X25519Keypair, X25519PublicKey, randomBytes, sha256Base64, toBase64, } from "@peerbit/crypto";
@@ -19,9 +43,11 @@ import { NO_ENCODING } from "./encoding.js";
 import { ShallowEntry, ShallowMeta } from "./entry-shallow.js";
 import { EntryType } from "./entry-type.js";
 import { Entry } from "./entry.js";
-import { logger } from "./logger.js";
+import { logger as baseLogger } from "./logger.js";
 import { Payload } from "./payload.js";
 import { equals } from "./utils.js";
+const log = baseLogger.newScope("entry-v0");
+const traceLogger = log.trace;
 const isMaybeEryptionPublicKey = (o) => {
     if (!o) {
         return true;
@@ -34,72 +60,102 @@ const isMaybeEryptionPublicKey = (o) => {
     }
     return false;
 };
-let Meta = class Meta {
-    clock;
-    gid; // graph id
-    next;
-    type;
-    data; // Optional metadata
-    constructor(properties) {
-        this.gid = properties.gid;
-        this.clock = properties.clock;
-        this.type = properties.type;
-        this.data = properties.data;
-        this.next = properties.next;
-    }
-};
-__decorate([
-    field({ type: Clock }),
-    __metadata("design:type", Clock)
-], Meta.prototype, "clock", void 0);
-__decorate([
-    field({ type: "string" }),
-    __metadata("design:type", String)
-], Meta.prototype, "gid", void 0);
-__decorate([
-    field({ type: vec("string") }),
-    __metadata("design:type", Array)
-], Meta.prototype, "next", void 0);
-__decorate([
-    field({ type: "u8" }),
-    __metadata("design:type", Number)
-], Meta.prototype, "type", void 0);
-__decorate([
-    field({ type: option(Uint8Array) }),
-    __metadata("design:type", Uint8Array)
-], Meta.prototype, "data", void 0);
-Meta = __decorate([
-    variant(0),
-    __metadata("design:paramtypes", [Object])
-], Meta);
+let Meta = (() => {
+    let _classDecorators = [variant(0)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _clock_decorators;
+    let _clock_initializers = [];
+    let _clock_extraInitializers = [];
+    let _gid_decorators;
+    let _gid_initializers = [];
+    let _gid_extraInitializers = [];
+    let _next_decorators;
+    let _next_initializers = [];
+    let _next_extraInitializers = [];
+    let _type_decorators;
+    let _type_initializers = [];
+    let _type_extraInitializers = [];
+    let _data_decorators;
+    let _data_initializers = [];
+    let _data_extraInitializers = [];
+    var Meta = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _clock_decorators = [field({ type: Clock })];
+            _gid_decorators = [field({ type: "string" })];
+            _next_decorators = [field({ type: vec("string") })];
+            _type_decorators = [field({ type: "u8" })];
+            _data_decorators = [field({ type: option(Uint8Array) })];
+            __esDecorate(null, null, _clock_decorators, { kind: "field", name: "clock", static: false, private: false, access: { has: obj => "clock" in obj, get: obj => obj.clock, set: (obj, value) => { obj.clock = value; } }, metadata: _metadata }, _clock_initializers, _clock_extraInitializers);
+            __esDecorate(null, null, _gid_decorators, { kind: "field", name: "gid", static: false, private: false, access: { has: obj => "gid" in obj, get: obj => obj.gid, set: (obj, value) => { obj.gid = value; } }, metadata: _metadata }, _gid_initializers, _gid_extraInitializers);
+            __esDecorate(null, null, _next_decorators, { kind: "field", name: "next", static: false, private: false, access: { has: obj => "next" in obj, get: obj => obj.next, set: (obj, value) => { obj.next = value; } }, metadata: _metadata }, _next_initializers, _next_extraInitializers);
+            __esDecorate(null, null, _type_decorators, { kind: "field", name: "type", static: false, private: false, access: { has: obj => "type" in obj, get: obj => obj.type, set: (obj, value) => { obj.type = value; } }, metadata: _metadata }, _type_initializers, _type_extraInitializers);
+            __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);
+            Meta = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        clock = __runInitializers(this, _clock_initializers, void 0);
+        gid = (__runInitializers(this, _clock_extraInitializers), __runInitializers(this, _gid_initializers, void 0)); // graph id
+        next = (__runInitializers(this, _gid_extraInitializers), __runInitializers(this, _next_initializers, void 0));
+        type = (__runInitializers(this, _next_extraInitializers), __runInitializers(this, _type_initializers, void 0));
+        data = (__runInitializers(this, _type_extraInitializers), __runInitializers(this, _data_initializers, void 0)); // Optional metadata
+        constructor(properties) {
+            __runInitializers(this, _data_extraInitializers);
+            this.gid = properties.gid;
+            this.clock = properties.clock;
+            this.type = properties.type;
+            this.data = properties.data;
+            this.next = properties.next;
+        }
+    };
+    return Meta = _classThis;
+})();
 export { Meta };
-let Signatures = class Signatures {
-    signatures;
-    constructor(properties) {
-        if (properties) {
-            this.signatures = properties.signatures;
+let Signatures = (() => {
+    let _classDecorators = [variant(0)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _signatures_decorators;
+    let _signatures_initializers = [];
+    let _signatures_extraInitializers = [];
+    var Signatures = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _signatures_decorators = [field({ type: vec(MaybeEncrypted) })];
+            __esDecorate(null, null, _signatures_decorators, { kind: "field", name: "signatures", static: false, private: false, access: { has: obj => "signatures" in obj, get: obj => obj.signatures, set: (obj, value) => { obj.signatures = value; } }, metadata: _metadata }, _signatures_initializers, _signatures_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Signatures = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-    }
-    equals(other) {
-        if (this.signatures.length !== other.signatures.length) {
-            return false;
+        signatures = __runInitializers(this, _signatures_initializers, void 0);
+        constructor(properties) {
+            __runInitializers(this, _signatures_extraInitializers);
+            if (properties) {
+                this.signatures = properties.signatures;
+            }
         }
-        for (let i = 0; i < this.signatures.length; i++) {
-            if (!this.signatures[i].equals(other.signatures[i])) {
+        equals(other) {
+            if (this.signatures.length !== other.signatures.length) {
                 return false;
             }
+            for (let i = 0; i < this.signatures.length; i++) {
+                if (!this.signatures[i].equals(other.signatures[i])) {
+                    return false;
+                }
+            }
+            return true;
         }
-        return true;
-    }
-};
-__decorate([
-    field({ type: vec(MaybeEncrypted) }),
-    __metadata("design:type", Array)
-], Signatures.prototype, "signatures", void 0);
-Signatures = __decorate([
-    variant(0),
-    __metadata("design:paramtypes", [Object])
-], Signatures);
+    };
+    return Signatures = _classThis;
+})();
 export { Signatures };
 const maybeEncrypt = (thing, keypair, receiver) => {
     const receivers = receiver
@@ -121,345 +177,359 @@ const maybeEncrypt = (thing, keypair, receiver) => {
         value: thing,
     });
 };
-let EntryV0 = EntryV0_1 = class EntryV0 extends Entry {
-    _meta;
-    _payload;
-    _reserved;
-    _signatures;
-    hash; // "zd...Foo", we'll set the hash after persisting the entry
-    createdLocally;
-    _keychain;
-    _encoding;
-    constructor(obj) {
-        super();
-        this._meta = obj.meta;
-        this._payload = obj.payload;
-        this._signatures = obj.signatures;
-        this._reserved = new Uint8Array([0, 0, 0, 0]);
-        this.createdLocally = obj.createdLocally;
-    }
-    init(props) {
-        if (props instanceof Entry) {
-            this._keychain = props._keychain;
-            this._encoding = props._encoding;
+let EntryV0 = (() => {
+    let _classDecorators = [variant(0)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = Entry;
+    let __meta_decorators;
+    let __meta_initializers = [];
+    let __meta_extraInitializers = [];
+    let __payload_decorators;
+    let __payload_initializers = [];
+    let __payload_extraInitializers = [];
+    let __reserved_decorators;
+    let __reserved_initializers = [];
+    let __reserved_extraInitializers = [];
+    let __signatures_decorators;
+    let __signatures_initializers = [];
+    let __signatures_extraInitializers = [];
+    let _hash_decorators;
+    let _hash_initializers = [];
+    let _hash_extraInitializers = [];
+    var EntryV0 = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __meta_decorators = [field({ type: MaybeEncrypted })];
+            __payload_decorators = [field({ type: MaybeEncrypted })];
+            __reserved_decorators = [field({ type: fixedArray("u8", 4) })];
+            __signatures_decorators = [field({ type: option(Signatures) })];
+            _hash_decorators = [field({ type: option("string") })];
+            __esDecorate(null, null, __meta_decorators, { kind: "field", name: "_meta", static: false, private: false, access: { has: obj => "_meta" in obj, get: obj => obj._meta, set: (obj, value) => { obj._meta = value; } }, metadata: _metadata }, __meta_initializers, __meta_extraInitializers);
+            __esDecorate(null, null, __payload_decorators, { kind: "field", name: "_payload", static: false, private: false, access: { has: obj => "_payload" in obj, get: obj => obj._payload, set: (obj, value) => { obj._payload = value; } }, metadata: _metadata }, __payload_initializers, __payload_extraInitializers);
+            __esDecorate(null, null, __reserved_decorators, { kind: "field", name: "_reserved", static: false, private: false, access: { has: obj => "_reserved" in obj, get: obj => obj._reserved, set: (obj, value) => { obj._reserved = value; } }, metadata: _metadata }, __reserved_initializers, __reserved_extraInitializers);
+            __esDecorate(null, null, __signatures_decorators, { kind: "field", name: "_signatures", static: false, private: false, access: { has: obj => "_signatures" in obj, get: obj => obj._signatures, set: (obj, value) => { obj._signatures = value; } }, metadata: _metadata }, __signatures_initializers, __signatures_extraInitializers);
+            __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);
+            EntryV0 = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-        else {
-            this._keychain = props.keychain;
-            this._encoding = props.encoding;
+        _meta = __runInitializers(this, __meta_initializers, void 0);
+        _payload = (__runInitializers(this, __meta_extraInitializers), __runInitializers(this, __payload_initializers, void 0));
+        _reserved = (__runInitializers(this, __payload_extraInitializers), __runInitializers(this, __reserved_initializers, void 0));
+        _signatures = (__runInitializers(this, __reserved_extraInitializers), __runInitializers(this, __signatures_initializers, void 0));
+        hash = (__runInitializers(this, __signatures_extraInitializers), __runInitializers(this, _hash_initializers, void 0)); // "zd...Foo", we'll set the hash after persisting the entry
+        createdLocally = __runInitializers(this, _hash_extraInitializers);
+        _keychain;
+        _encoding;
+        constructor(obj) {
+            super();
+            this._meta = obj.meta;
+            this._payload = obj.payload;
+            this._signatures = obj.signatures;
+            this._reserved = new Uint8Array([0, 0, 0, 0]);
+            this.createdLocally = obj.createdLocally;
         }
-        return this;
-    }
-    get encoding() {
-        if (!this._encoding) {
-            throw new Error("Not initialized");
+        init(props) {
+            if (props instanceof Entry) {
+                this._keychain = props._keychain;
+                this._encoding = props._encoding;
+            }
+            else {
+                this._keychain = props.keychain;
+                this._encoding = props.encoding;
+            }
+            return this;
         }
-        return this._encoding;
-    }
-    get meta() {
-        return this._meta.decrypted.getValue(Meta);
-    }
-    async getMeta() {
-        await this._meta.decrypt(this._keychain);
-        return this.meta;
-    }
-    async getClock() {
-        return (await this.getMeta()).clock;
-    }
-    get gid() {
-        return this._meta.decrypted.getValue(Meta).gid;
-    }
-    async getGid() {
-        return (await this.getMeta()).gid;
-    }
-    get payload() {
-        const payload = this._payload.decrypted.getValue(Payload);
-        payload.encoding = payload.encoding || this.encoding;
-        return payload;
-    }
-    async getPayload() {
-        if (this._payload instanceof DecryptedThing) {
-            return this.payload;
+        get encoding() {
+            if (!this._encoding) {
+                throw new Error("Not initialized");
+            }
+            return this._encoding;
         }
-        await this._payload.decrypt(this._keychain);
-        return this.payload;
-    }
-    async getPayloadValue() {
-        const payload = await this.getPayload();
-        return payload.isDecoded ? payload.value : payload.getValue(this.encoding);
-    }
-    get publicKeys() {
-        return this.signatures.map((x) => x.publicKey);
-    }
-    get next() {
-        return this.meta.next;
-    }
-    async getNext() {
-        return (await this.getMeta()).next;
-    }
-    _size;
-    set size(number) {
-        this._size = number;
-    }
-    get size() {
-        if (this._size == null) {
-            throw new Error("Size not set. Size is set when entry is, created, loaded or joined");
+        get meta() {
+            return this._meta.decrypted.getValue(Meta);
         }
-        return this._size;
-    }
-    /**
-     * Will only return signatures I can decrypt
-     * @returns signatures
-     */
-    get signatures() {
-        const signatures = this._signatures.signatures.filter((x) => {
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-                x.decrypted;
-                return true;
+        async getMeta() {
+            await this._meta.decrypt(this._keychain);
+            return this.meta;
+        }
+        async getClock() {
+            return (await this.getMeta()).clock;
+        }
+        get gid() {
+            return this._meta.decrypted.getValue(Meta).gid;
+        }
+        async getGid() {
+            return (await this.getMeta()).gid;
+        }
+        get payload() {
+            const payload = this._payload.decrypted.getValue(Payload);
+            payload.encoding = payload.encoding || this.encoding;
+            return payload;
+        }
+        async getPayload() {
+            if (this._payload instanceof DecryptedThing) {
+                return this.payload;
             }
-            catch (error) {
-                return false;
+            await this._payload.decrypt(this._keychain);
+            return this.payload;
+        }
+        async getPayloadValue() {
+            const payload = await this.getPayload();
+            return payload.isDecoded ? payload.value : payload.getValue(this.encoding);
+        }
+        get publicKeys() {
+            return this.signatures.map((x) => x.publicKey);
+        }
+        get next() {
+            return this.meta.next;
+        }
+        async getNext() {
+            return (await this.getMeta()).next;
+        }
+        _size;
+        set size(number) {
+            this._size = number;
+        }
+        get size() {
+            if (this._size == null) {
+                throw new Error("Size not set. Size is set when entry is, created, loaded or joined");
             }
-        }).map((x) => x.decrypted.getValue(SignatureWithKey));
-        if (signatures.length === 0) {
-            this._signatures?.signatures.forEach((x) => x.clear());
-            throw new Error("Failed to resolve any signature");
+            return this._size;
         }
-        return signatures;
-    }
-    /**
-     * Will only return signatures I can decrypt
-     * @returns signatures
-     */
-    async getSignatures() {
-        const results = await Promise.allSettled(this._signatures.signatures.map((x) => x.decrypt(this._keychain)));
-        if (logger.level === "debug" || logger.level === "trace") {
-            for (const [i, result] of results.entries()) {
-                if (result.status === "rejected") {
-                    logger.debug("Failed to decrypt signature with index: " + i);
+        /**
+         * Will only return signatures I can decrypt
+         * @returns signatures
+         */
+        get signatures() {
+            const signatures = this._signatures.signatures.filter((x) => {
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                    x.decrypted;
+                    return true;
+                }
+                catch (error) {
+                    return false;
                 }
+            }).map((x) => x.decrypted.getValue(SignatureWithKey));
+            if (signatures.length === 0) {
+                this._signatures?.signatures.forEach((x) => x.clear());
+                throw new Error("Failed to resolve any signature");
             }
+            return signatures;
         }
-        return this.signatures;
-    }
-    /**
-     * Will only verify signatures I can decrypt
-     * @returns true if all are verified
-     */
-    async verifySignatures() {
-        const signatures = await this.getSignatures();
-        if (signatures.length === 0) {
-            return false;
+        /**
+         * Will only return signatures I can decrypt
+         * @returns signatures
+         */
+        async getSignatures() {
+            const results = await Promise.allSettled(this._signatures.signatures.map((x) => x.decrypt(this._keychain)));
+            if (traceLogger?.enabled) {
+                for (const [i, result] of results.entries()) {
+                    if (result.status === "rejected") {
+                        traceLogger("Failed to decrypt signature with index: " + i);
+                    }
+                }
+            }
+            return this.signatures;
         }
-        const signable = EntryV0_1.toSignable(this);
-        const signableBytes = serialize(signable);
-        for (const signature of signatures) {
-            if (!(await verify(signature, signableBytes))) {
+        /**
+         * Will only verify signatures I can decrypt
+         * @returns true if all are verified
+         */
+        async verifySignatures() {
+            const signatures = await this.getSignatures();
+            if (signatures.length === 0) {
                 return false;
             }
+            const signable = EntryV0.toSignable(this);
+            const signableBytes = serialize(signable);
+            for (const signature of signatures) {
+                if (!(await verify(signature, signableBytes))) {
+                    return false;
+                }
+            }
+            return true;
         }
-        return true;
-    }
-    static toSignable(entry) {
-        // TODO fix types
-        const trimmed = new EntryV0_1({
-            meta: entry._meta,
-            payload: entry._payload,
-            reserved: entry._reserved,
-            signatures: undefined,
-            hash: undefined,
-        });
-        return trimmed;
-    }
-    toSignable() {
-        if (this._signatures) {
-            throw new Error("Expected signatures to be undefined");
+        static toSignable(entry) {
+            // TODO fix types
+            const trimmed = new EntryV0({
+                meta: entry._meta,
+                payload: entry._payload,
+                reserved: entry._reserved,
+                signatures: undefined,
+                hash: undefined,
+            });
+            return trimmed;
         }
-        if (this.hash) {
-            throw new Error("Expected hash to be undefined");
+        toSignable() {
+            if (this._signatures) {
+                throw new Error("Expected signatures to be undefined");
+            }
+            if (this.hash) {
+                throw new Error("Expected hash to be undefined");
+            }
+            return EntryV0.toSignable(this);
         }
-        return EntryV0_1.toSignable(this);
-    }
-    equals(other) {
-        if (other instanceof EntryV0_1) {
-            return (equals(this._reserved, other._reserved) &&
-                this._meta.equals(other._meta) &&
-                this._signatures.equals(other._signatures) &&
-                this._payload.equals(other._payload)); // dont compare hashes because the hash is a function of the other properties
-        }
-        return false;
-    }
-    async delete(store) {
-        if (!this.hash) {
-            throw new Error("Missing hash");
+        equals(other) {
+            if (other instanceof EntryV0) {
+                return (equals(this._reserved, other._reserved) &&
+                    this._meta.equals(other._meta) &&
+                    this._signatures.equals(other._signatures) &&
+                    this._payload.equals(other._payload)); // dont compare hashes because the hash is a function of the other properties
+            }
+            return false;
         }
-        await store.rm(this.hash);
-    }
-    static createGid(seed) {
-        return seed ? sha256Base64(seed) : toBase64(randomBytes(32));
-    }
-    static async create(properties) {
-        if (!properties.encoding || !properties?.meta?.next) {
-            properties = {
-                ...properties,
-                meta: {
-                    ...properties?.meta,
-                    next: properties.meta?.next ? properties.meta?.next : [],
-                },
-                encoding: properties.encoding ? properties.encoding : NO_ENCODING,
-            };
-        }
-        if (!properties.encoding) {
-            throw new Error("Missing encoding options");
-        }
-        if (properties.data == null)
-            throw new Error("Entry requires data");
-        if (properties.meta?.next == null || !Array.isArray(properties.meta.next))
-            throw new Error("'next' argument is not an array");
-        // Clean the next objects and convert to hashes
-        const nexts = properties.meta?.next;
-        const payloadToSave = new Payload({
-            data: properties.encoding.encoder(properties.data),
-            value: properties.data,
-            encoding: properties.encoding,
-        });
-        let clock = properties.meta?.clock;
-        if (!clock) {
-            const hlc = new HLC();
-            for (const next of nexts) {
-                hlc.update(next.meta.clock.timestamp);
+        async delete(store) {
+            if (!this.hash) {
+                throw new Error("Missing hash");
             }
-            if (properties.encryption?.receiver.signatures &&
-                properties.encryption?.receiver.meta) {
-                throw new Error("Signature is to be encrypted yet the clock is not, which contains the publicKey as id. Either provide a custom Clock value that is not sensitive or set the receiver (encryption target) for the clock");
+            await store.rm(this.hash);
+        }
+        static createGid(seed) {
+            return seed ? sha256Base64(seed) : toBase64(randomBytes(32));
+        }
+        static async create(properties) {
+            if (!properties.encoding || !properties?.meta?.next) {
+                properties = {
+                    ...properties,
+                    meta: {
+                        ...properties?.meta,
+                        next: properties.meta?.next ? properties.meta?.next : [],
+                    },
+                    encoding: properties.encoding ? properties.encoding : NO_ENCODING,
+                };
+            }
+            if (!properties.encoding) {
+                throw new Error("Missing encoding options");
             }
-            clock = new Clock({
-                id: properties.identity.publicKey.bytes,
-                timestamp: hlc.now(),
+            if (properties.data == null)
+                throw new Error("Entry requires data");
+            if (properties.meta?.next == null || !Array.isArray(properties.meta.next))
+                throw new Error("'next' argument is not an array");
+            // Clean the next objects and convert to hashes
+            const nexts = properties.meta?.next;
+            const payloadToSave = new Payload({
+                data: properties.encoding.encoder(properties.data),
+                value: properties.data,
+                encoding: properties.encoding,
             });
-        }
-        else {
-            const cv = clock;
-            // check if nexts, that all nexts are happening BEFORE this clock value (else clock make no sense)
-            for (const n of nexts) {
-                if (Timestamp.compare(n.meta.clock.timestamp, cv.timestamp) >= 0) {
-                    throw new Error("Expecting next(s) to happen before entry, got: " +
-                        n.meta.clock.timestamp +
-                        " > " +
-                        cv.timestamp);
+            let clock = properties.meta?.clock;
+            if (!clock) {
+                const hlc = new HLC();
+                for (const next of nexts) {
+                    hlc.update(next.meta.clock.timestamp);
+                }
+                if (properties.encryption?.receiver.signatures &&
+                    properties.encryption?.receiver.meta) {
+                    throw new Error("Signature is to be encrypted yet the clock is not, which contains the publicKey as id. Either provide a custom Clock value that is not sensitive or set the receiver (encryption target) for the clock");
                 }
+                clock = new Clock({
+                    id: properties.identity.publicKey.bytes,
+                    timestamp: hlc.now(),
+                });
             }
-        }
-        const nextHashes = [];
-        let maxChainLength = 0n;
-        let gid = null;
-        if (nexts?.length > 0) {
-            // take min gid as our gid
-            if (properties.meta?.gid) {
-                throw new Error("Expecting '.meta.gid' property to be undefined if '.meta.next' is provided");
+            else {
+                const cv = clock;
+                // check if nexts, that all nexts are happening BEFORE this clock value (else clock make no sense)
+                for (const n of nexts) {
+                    if (Timestamp.compare(n.meta.clock.timestamp, cv.timestamp) >= 0) {
+                        throw new Error("Expecting next(s) to happen before entry, got: " +
+                            n.meta.clock.timestamp +
+                            " > " +
+                            cv.timestamp);
+                    }
+                }
             }
-            for (const n of nexts) {
-                if (!n.hash) {
-                    throw new Error("Expecting hash to be defined to next entries");
+            const nextHashes = [];
+            let gid = null;
+            if (nexts?.length > 0) {
+                // take min gid as our gid
+                if (properties.meta?.gid) {
+                    throw new Error("Expecting '.meta.gid' property to be undefined if '.meta.next' is provided");
                 }
-                nextHashes.push(n.hash);
-                gid =
-                    gid == null
-                        ? n.meta.gid
-                        : n.meta.gid < gid
+                for (const n of nexts) {
+                    if (!n.hash) {
+                        throw new Error("Expecting hash to be defined to next entries");
+                    }
+                    nextHashes.push(n.hash);
+                    gid =
+                        gid == null
                             ? n.meta.gid
-                            : gid;
+                            : n.meta.gid < gid
+                                ? n.meta.gid
+                                : gid;
+                }
+            }
+            else {
+                gid =
+                    properties.meta?.gid ||
+                        (await EntryV0.createGid(properties.meta?.gidSeed));
             }
+            const metadataEncrypted = await maybeEncrypt(new Meta({
+                clock,
+                gid: gid,
+                type: properties.meta?.type ?? EntryType.APPEND,
+                data: properties.meta?.data,
+                next: nextHashes,
+            }), properties.encryption?.keypair, properties.encryption?.receiver.meta);
+            const payload = await maybeEncrypt(payloadToSave, properties.encryption?.keypair, properties.encryption?.receiver.payload);
+            // Sign id, encrypted payload, clock, nexts, refs
+            const entry = new EntryV0({
+                meta: metadataEncrypted,
+                payload,
+                signatures: undefined,
+                createdLocally: true,
+            });
+            const signers = properties.signers || [
+                properties.identity.sign.bind(properties.identity),
+            ];
+            const signableBytes = serialize(entry.toSignable());
+            let signatures = await Promise.all(signers.map((signer) => signer(signableBytes)));
+            signatures = signatures.sort((a, b) => compare(a.signature, b.signature));
+            const encryptedSignatures = [];
+            const encryptAllSignaturesWithSameKey = isMaybeEryptionPublicKey(properties.encryption?.receiver?.signatures);
+            for (const signature of signatures) {
+                const encryptionRecievers = encryptAllSignaturesWithSameKey
+                    ? properties.encryption?.receiver?.signatures
+                    : properties.encryption?.receiver?.signatures?.[signature.publicKey.hashcode()]; // TODO types
+                const signatureEncrypted = await maybeEncrypt(signature, properties.encryption?.keypair, encryptionRecievers);
+                encryptedSignatures.push(signatureEncrypted);
+            }
+            entry._signatures = new Signatures({
+                signatures: encryptedSignatures,
+            });
+            if (properties.canAppend && !(await properties.canAppend(entry))) {
+                throw new AccessError("Not allowed to append");
+            }
+            // Append hash
+            entry.hash = await Entry.toMultihash(properties.store, entry);
+            entry.init({ encoding: properties.encoding });
+            return entry;
         }
-        else {
-            gid =
-                properties.meta?.gid ||
-                    (await EntryV0_1.createGid(properties.meta?.gidSeed));
-        }
-        maxChainLength += 1n; // include this
-        const metadataEncrypted = await maybeEncrypt(new Meta({
-            clock,
-            gid: gid,
-            type: properties.meta?.type ?? EntryType.APPEND,
-            data: properties.meta?.data,
-            next: nextHashes,
-        }), properties.encryption?.keypair, properties.encryption?.receiver.meta);
-        const payload = await maybeEncrypt(payloadToSave, properties.encryption?.keypair, properties.encryption?.receiver.payload);
-        // Sign id, encrypted payload, clock, nexts, refs
-        const entry = new EntryV0_1({
-            meta: metadataEncrypted,
-            payload,
-            signatures: undefined,
-            createdLocally: true,
-        });
-        const signers = properties.signers || [
-            properties.identity.sign.bind(properties.identity),
-        ];
-        const signableBytes = serialize(entry.toSignable());
-        let signatures = await Promise.all(signers.map((signer) => signer(signableBytes)));
-        signatures = signatures.sort((a, b) => compare(a.signature, b.signature));
-        const encryptedSignatures = [];
-        const encryptAllSignaturesWithSameKey = isMaybeEryptionPublicKey(properties.encryption?.receiver?.signatures);
-        for (const signature of signatures) {
-            const encryptionRecievers = encryptAllSignaturesWithSameKey
-                ? properties.encryption?.receiver?.signatures
-                : properties.encryption?.receiver?.signatures?.[signature.publicKey.hashcode()]; // TODO types
-            const signatureEncrypted = await maybeEncrypt(signature, properties.encryption?.keypair, encryptionRecievers);
-            encryptedSignatures.push(signatureEncrypted);
-        }
-        entry._signatures = new Signatures({
-            signatures: encryptedSignatures,
-        });
-        if (properties.canAppend && !(await properties.canAppend(entry))) {
-            throw new AccessError("Not allowed to append");
-        }
-        // Append hash
-        entry.hash = await Entry.toMultihash(properties.store, entry);
-        entry.init({ encoding: properties.encoding });
-        return entry;
-    }
-    get payloadByteLength() {
-        return this._payload.byteLength;
-    }
-    toShallow(isHead) {
-        return new ShallowEntry({
-            hash: this.hash,
-            payloadSize: this._payload.byteLength,
-            head: isHead,
-            meta: new ShallowMeta({
-                gid: this.meta.gid,
-                data: this.meta.data,
-                clock: this.meta.clock,
-                next: this.meta.next,
-                type: this.meta.type,
-            }),
-        });
-    }
-};
-__decorate([
-    field({ type: MaybeEncrypted }),
-    __metadata("design:type", MaybeEncrypted)
-], EntryV0.prototype, "_meta", void 0);
-__decorate([
-    field({ type: MaybeEncrypted }),
-    __metadata("design:type", MaybeEncrypted)
-], EntryV0.prototype, "_payload", void 0);
-__decorate([
-    field({ type: fixedArray("u8", 4) }),
-    __metadata("design:type", Uint8Array)
-], EntryV0.prototype, "_reserved", void 0);
-__decorate([
-    field({ type: option(Signatures) }),
-    __metadata("design:type", Signatures)
-], EntryV0.prototype, "_signatures", void 0);
-__decorate([
-    field({ type: option("string") }) // we do option because we serialize and store this in a block without the hash, to receive the hash, which we later set
-    ,
-    __metadata("design:type", String)
-], EntryV0.prototype, "hash", void 0);
-EntryV0 = EntryV0_1 = __decorate([
-    variant(0),
-    __metadata("design:paramtypes", [Object])
-], EntryV0);
+        get payloadByteLength() {
+            return this._payload.byteLength;
+        }
+        toShallow(isHead) {
+            return new ShallowEntry({
+                hash: this.hash,
+                payloadSize: this._payload.byteLength,
+                head: isHead,
+                meta: new ShallowMeta({
+                    gid: this.meta.gid,
+                    data: this.meta.data,
+                    clock: this.meta.clock,
+                    next: this.meta.next,
+                    type: this.meta.type,
+                }),
+            });
+        }
+    };
+    return EntryV0 = _classThis;
+})();
 export { EntryV0 };
 //# sourceMappingURL=entry-v0.js.map