@peerbit/log 6.1.1 → 6.2.0

package/dist/src/entry-v0.js

@@ -32,9 +32,17 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-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";
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { deserialize, field, fixedArray, option, serialize, variant, vec, } from "@dao-xyz/borsh";
+import { calculateRawCid } from "@peerbit/blocks-interface";
+import { AccessError, DecryptedThing, Ed25519Keypair, Ed25519PublicKey, MaybeEncrypted, PublicSignKey, SignatureWithKey, X25519Keypair, X25519PublicKey, randomBytes, sha256Base64, toBase64, } from "@peerbit/crypto";
 import { verify } from "@peerbit/crypto";
 import {} from "@peerbit/keychain";
 import { compare } from "uint8arrays";
@@ -42,12 +50,223 @@ import { LamportClock as Clock, HLC, Timestamp } from "./clock.js";
 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 { Entry, } from "./entry.js";
 import { logger as baseLogger } from "./logger.js";
 import { Payload } from "./payload.js";
+import { canUseOptionalNativeModuleImports } from "./runtime.js";
 import { equals } from "./utils.js";
 const log = baseLogger.newScope("entry-v0");
 const traceLogger = log.trace;
+const RANDOM_GID_BYTES = 32;
+const RANDOM_GID_POOL_SIZE = 64;
+const NATIVE_RAW_CID_BATCH_MIN_BYTES = 1 << 20;
+let randomGidPool = [];
+const createRandomGid = () => {
+    if (randomGidPool.length === 0) {
+        const bytes = randomBytes(RANDOM_GID_BYTES * RANDOM_GID_POOL_SIZE);
+        randomGidPool = new Array(RANDOM_GID_POOL_SIZE);
+        for (let i = 0; i < RANDOM_GID_POOL_SIZE; i++) {
+            const offset = i * RANDOM_GID_BYTES;
+            randomGidPool[i] = toBase64(bytes.subarray(offset, offset + RANDOM_GID_BYTES));
+        }
+    }
+    return randomGidPool.pop();
+};
+let nativeEntryV0EncoderPromise;
+let nativeEntryV0EncoderLoaded = false;
+let nativeEntryV0Encoder;
+const isPromiseLike = (value) => !!value && typeof value.then === "function";
+const getSynchronousBlockBytes = (store, cid) => {
+    const value = store?.get?.(cid);
+    return value instanceof Uint8Array ? value : undefined;
+};
+const nativeEntryV0EncoderFromModule = (mod) => {
+    if (!mod.encodeEntryV0Signable ||
+        !mod.encodeEntryV0Storage ||
+        !mod.calculateRawCidV1) {
+        return undefined;
+    }
+    return {
+        encodeEntryV0Signable: mod.encodeEntryV0Signable,
+        encodeEntryV0Storage: mod.encodeEntryV0Storage,
+        encodeEntryV0StorageWithCid: mod.encodeEntryV0StorageWithCid,
+        prepareEntryV0PlainChain: mod.prepareEntryV0PlainChain,
+        prepareEntryV0PlainEntry: mod.prepareEntryV0PlainEntry,
+        calculateRawCidV1: mod.calculateRawCidV1,
+        calculateRawCidV1Batch: mod.calculateRawCidV1Batch,
+        entryV0PlainPayloadDataFromStorage: mod.entryV0PlainPayloadDataFromStorage,
+        prepareRawEntryV0Batch: mod.prepareRawEntryV0Batch,
+        verifyEd25519Batch: mod.verifyEd25519Batch,
+        verifyEntryV0Ed25519Batch: mod.verifyEntryV0Ed25519Batch,
+        verifyEntryV0Ed25519StorageBatch: mod.verifyEntryV0Ed25519StorageBatch,
+    };
+};
+const loadNativeEntryV0Encoder = () => {
+    if (nativeEntryV0EncoderLoaded) {
+        return nativeEntryV0Encoder;
+    }
+    if (!canUseOptionalNativeModuleImports()) {
+        nativeEntryV0EncoderLoaded = true;
+        return undefined;
+    }
+    if (!nativeEntryV0EncoderPromise) {
+        try {
+            nativeEntryV0EncoderPromise = import(__rewriteRelativeImportExtension(
+            /* @vite-ignore */ ["@peerbit", "log-rust"].join("/")))
+                .then((mod) => {
+                nativeEntryV0Encoder = nativeEntryV0EncoderFromModule(mod);
+                nativeEntryV0EncoderLoaded = true;
+                return nativeEntryV0Encoder;
+            })
+                .catch(() => {
+                nativeEntryV0Encoder = undefined;
+                nativeEntryV0EncoderLoaded = true;
+                return undefined;
+            });
+        }
+        catch {
+            nativeEntryV0Encoder = undefined;
+            nativeEntryV0EncoderLoaded = true;
+            return undefined;
+        }
+    }
+    return nativeEntryV0EncoderPromise;
+};
+export const calculateRawCidV1Batch = async (blocks) => {
+    if (blocks.length === 0) {
+        return [];
+    }
+    const totalBytes = blocks.reduce((sum, block) => sum + block.byteLength, 0);
+    if (totalBytes < NATIVE_RAW_CID_BATCH_MIN_BYTES) {
+        // Small raw-head messages are faster through the JS hasher because they
+        // avoid copying every block into wasm.
+        return Promise.all(blocks.map(async (bytes) => (await calculateRawCid(bytes)).cid));
+    }
+    const nativeEncoder = loadNativeEntryV0Encoder();
+    const resolvedNativeEncoder = isPromiseLike(nativeEncoder)
+        ? await nativeEncoder
+        : nativeEncoder;
+    if (resolvedNativeEncoder?.calculateRawCidV1Batch) {
+        return resolvedNativeEncoder.calculateRawCidV1Batch(blocks);
+    }
+    return Promise.all(blocks.map(async (bytes) => (await calculateRawCid(bytes)).cid));
+};
+export const prepareRawEntryV0Batch = async (blocks) => {
+    if (blocks.length === 0) {
+        return [];
+    }
+    const nativeEncoder = loadNativeEntryV0Encoder();
+    const resolvedNativeEncoder = isPromiseLike(nativeEncoder)
+        ? await nativeEncoder
+        : nativeEncoder;
+    return resolvedNativeEncoder?.prepareRawEntryV0Batch?.(blocks);
+};
+export const entryV0PlainPayloadDataFromStorage = async (bytes) => {
+    const nativeEncoder = loadNativeEntryV0Encoder();
+    const resolvedNativeEncoder = isPromiseLike(nativeEncoder)
+        ? await nativeEncoder
+        : nativeEncoder;
+    return resolvedNativeEncoder?.entryV0PlainPayloadDataFromStorage?.(bytes);
+};
+export const verifyEd25519Batch = async (inputs) => {
+    if (inputs.length === 0) {
+        return [];
+    }
+    const nativeEncoder = loadNativeEntryV0Encoder();
+    const resolvedNativeEncoder = isPromiseLike(nativeEncoder)
+        ? await nativeEncoder
+        : nativeEncoder;
+    return resolvedNativeEncoder?.verifyEd25519Batch?.(inputs);
+};
+export const verifyEntryV0Ed25519Batch = async (inputs) => {
+    if (inputs.length === 0) {
+        return [];
+    }
+    const nativeEncoder = loadNativeEntryV0Encoder();
+    const resolvedNativeEncoder = isPromiseLike(nativeEncoder)
+        ? await nativeEncoder
+        : nativeEncoder;
+    return resolvedNativeEncoder?.verifyEntryV0Ed25519Batch?.(inputs);
+};
+export const verifyEntryV0Ed25519StorageBatch = async (blocks) => {
+    if (blocks.length === 0) {
+        return [];
+    }
+    const nativeEncoder = loadNativeEntryV0Encoder();
+    const resolvedNativeEncoder = isPromiseLike(nativeEncoder)
+        ? await nativeEncoder
+        : nativeEncoder;
+    return resolvedNativeEncoder?.verifyEntryV0Ed25519StorageBatch?.(blocks);
+};
+export const verifyEntryV0Ed25519BatchFromEntries = async (entries) => {
+    if (entries.length === 0) {
+        return [];
+    }
+    const preparedStorageBytes = [];
+    let allHavePreparedStorageBytes = true;
+    for (const entry of entries) {
+        const bytes = Entry.getPreparedStorageBytes(entry);
+        if (!bytes) {
+            allHavePreparedStorageBytes = false;
+            break;
+        }
+        preparedStorageBytes.push(bytes);
+    }
+    if (allHavePreparedStorageBytes) {
+        try {
+            const verified = await verifyEntryV0Ed25519StorageBatch(preparedStorageBytes);
+            if (verified) {
+                return verified;
+            }
+        }
+        catch {
+            // Fall through to field extraction for encrypted or non-Ed25519 entries.
+        }
+    }
+    const inputs = [];
+    for (const entry of entries) {
+        if (!(entry instanceof EntryV0)) {
+            return undefined;
+        }
+        const rawEntry = entry;
+        if (!(rawEntry._meta instanceof DecryptedThing) ||
+            !(rawEntry._payload instanceof DecryptedThing)) {
+            return undefined;
+        }
+        let signatures;
+        let meta;
+        let payload;
+        try {
+            signatures = entry.signatures;
+            meta = entry.meta;
+            payload = entry.payload;
+        }
+        catch {
+            return undefined;
+        }
+        if (signatures.length !== 1) {
+            return undefined;
+        }
+        const signature = signatures[0];
+        if (!(signature.publicKey instanceof Ed25519PublicKey) ||
+            signature.prehash !== 0) {
+            return undefined;
+        }
+        inputs.push({
+            clockId: meta.clock.id,
+            wallTime: meta.clock.timestamp.wallTime,
+            logical: meta.clock.timestamp.logical,
+            gid: meta.gid,
+            next: meta.next,
+            type: meta.type,
+            metaData: meta.data,
+            payloadData: payload.data,
+            signature: signature.signature,
+            publicKey: signature.publicKey.publicKey,
+        });
+    }
+    return verifyEntryV0Ed25519Batch(inputs);
+};
 const isMaybeEryptionPublicKey = (o) => {
     if (!o) {
         return true;
@@ -225,6 +444,7 @@ let EntryV0 = (() => {
         createdLocally = __runInitializers(this, _hash_extraInitializers);
         _keychain;
         _encoding;
+        _hashDigestBytes;
         constructor(obj) {
             super();
             this._meta = obj.meta;
@@ -257,6 +477,17 @@ let EntryV0 = (() => {
             await this._meta.decrypt(this._keychain);
             return this.meta;
         }
+        getMetaBytes() {
+            try {
+                return this._meta.decrypted._data;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        getHashDigestBytes() {
+            return this._hashDigestBytes;
+        }
         async getClock() {
             return (await this.getMeta()).clock;
         }
@@ -393,7 +624,738 @@ let EntryV0 = (() => {
             await store.rm(this.hash);
         }
         static createGid(seed) {
-            return seed ? sha256Base64(seed) : toBase64(randomBytes(32));
+            return seed ? sha256Base64(seed) : createRandomGid();
+        }
+        static createGids(count) {
+            if (count === 0) {
+                return [];
+            }
+            const bytes = randomBytes(count * RANDOM_GID_BYTES);
+            const gids = new Array(count);
+            for (let i = 0; i < count; i++) {
+                const offset = i * RANDOM_GID_BYTES;
+                gids[i] = toBase64(bytes.subarray(offset, offset + RANDOM_GID_BYTES));
+            }
+            return gids;
+        }
+        static async createPlainAppendChain(properties) {
+            return (await EntryV0.createPlainAppendChainBatch(properties))?.entries;
+        }
+        static async createPlainAppendEntriesBatch(properties) {
+            if (!properties.deferStore) {
+                return undefined;
+            }
+            if (!(properties.identity instanceof Ed25519Keypair)) {
+                return undefined;
+            }
+            const nativeCommit = properties.nativeGraph?.prepareEntryV0PlainEntriesCommit;
+            if (!nativeCommit) {
+                return undefined;
+            }
+            if (properties.meta.gids.length !== properties.data.length ||
+                (properties.meta.nexts &&
+                    properties.meta.nexts.length !== properties.data.length) ||
+                (properties.payloadDatas &&
+                    properties.payloadDatas.length !== properties.data.length)) {
+                throw new Error("Expected one gid and next list per entry");
+            }
+            const clocks = properties.meta.clocks();
+            if (clocks.length !== properties.data.length) {
+                throw new Error("Expected one clock per entry");
+            }
+            for (let i = 0; i < clocks.length; i++) {
+                for (const next of properties.meta.nexts?.[i] ?? []) {
+                    if (Timestamp.compare(next.meta.clock.timestamp, clocks[i].timestamp) >=
+                        0) {
+                        throw new Error("Expecting next(s) to happen before entry, got: " +
+                            next.meta.clock.timestamp +
+                            " > " +
+                            clocks[i].timestamp);
+                    }
+                }
+            }
+            const payloadDatas = properties.payloadDatas ??
+                properties.data.map((data) => properties.encoding.encoder(data));
+            const input = {
+                clockId: properties.identity.publicKey.bytes,
+                privateKey: properties.identity.privateKey.privateKey,
+                publicKey: properties.identity.publicKey.publicKey,
+                wallTimes: clocks.map((clock) => clock.timestamp.wallTime),
+                logicals: clocks.map((clock) => clock.timestamp.logical),
+                gids: properties.meta.gids,
+                nexts: properties.meta.nexts?.map((nexts) => nexts.map((next) => next.hash)),
+                type: properties.meta.type,
+                metaDatas: properties.meta.datas,
+                payloadDatas,
+            };
+            const preparedValue = nativeCommit.call(properties.nativeGraph, input, properties.nativeBlockStore);
+            const prepared = isPromiseLike(preparedValue)
+                ? await preparedValue
+                : preparedValue;
+            if (!prepared) {
+                return undefined;
+            }
+            if (prepared.length !== properties.data.length) {
+                throw new Error("Unexpected prepared entry batch length");
+            }
+            const entries = [];
+            const shallowEntries = [];
+            const appendFacts = [];
+            const nativeEntries = [];
+            const entryType = properties.meta.type ?? EntryType.APPEND;
+            for (let index = 0; index < prepared.length; index++) {
+                const preparedEntry = prepared[index];
+                const clock = clocks[index];
+                const entryGid = properties.meta.gids[index];
+                const metaData = properties.meta.datas?.[index];
+                const meta = new Meta({
+                    clock,
+                    gid: entryGid,
+                    type: entryType,
+                    data: metaData,
+                    next: preparedEntry.next,
+                });
+                const payloadSize = payloadDatas[index].byteLength;
+                const payload = properties.cachePreparedEntries === false
+                    ? undefined
+                    : new Payload({
+                        data: payloadDatas[index],
+                        value: properties.data[index],
+                        encoding: properties.encoding,
+                    });
+                const signature = properties.cachePreparedEntries === false
+                    ? undefined
+                    : new SignatureWithKey({
+                        signature: preparedEntry.signature,
+                        publicKey: properties.identity.publicKey,
+                        prehash: 0,
+                    });
+                const entry = new EntryV0({
+                    meta: new DecryptedThing({
+                        data: preparedEntry.metaBytes,
+                        value: meta,
+                    }),
+                    payload: new DecryptedThing({
+                        data: preparedEntry.payloadBytes,
+                        value: payload,
+                    }),
+                    signatures: new Signatures({
+                        signatures: [
+                            new DecryptedThing({
+                                data: preparedEntry.signatureBytes,
+                                value: signature,
+                            }),
+                        ],
+                    }),
+                    createdLocally: true,
+                });
+                if (properties.cachePreparedEntries === false) {
+                    entry.hash = preparedEntry.cid;
+                    entry.size = preparedEntry.byteLength;
+                }
+                else {
+                    if (!preparedEntry.bytes) {
+                        throw new Error("Missing prepared entry bytes");
+                    }
+                    entry.hash = Entry.prepareMultihashBytes(entry, preparedEntry.bytes, preparedEntry.cid);
+                }
+                entry._hashDigestBytes = preparedEntry.hashDigestBytes;
+                const shallowEntry = new ShallowEntry({
+                    hash: entry.hash,
+                    payloadSize,
+                    head: true,
+                    meta: new ShallowMeta({
+                        gid: entryGid,
+                        data: metaData,
+                        clock,
+                        next: preparedEntry.next,
+                        type: entryType,
+                    }),
+                });
+                const nativeEntry = properties.cachePreparedEntries === false
+                    ? undefined
+                    : {
+                        hash: entry.hash,
+                        gid: entryGid,
+                        next: preparedEntry.next,
+                        type: entryType,
+                        head: true,
+                        payloadSize,
+                        data: metaData,
+                        clock: {
+                            timestamp: {
+                                wallTime: clock.timestamp.wallTime,
+                                logical: clock.timestamp.logical,
+                            },
+                        },
+                    };
+                if (properties.cachePreparedEntries !== false) {
+                    Entry.prepareShallowEntry(entry, shallowEntry);
+                    Entry.prepareNativeLogEntry(entry, nativeEntry);
+                    entry.init({ encoding: properties.encoding });
+                }
+                entries.push(entry);
+                shallowEntries.push(shallowEntry);
+                appendFacts.push({
+                    hash: entry.hash,
+                    gid: entryGid,
+                    next: preparedEntry.next,
+                    wallTime: clock.timestamp.wallTime,
+                    logical: clock.timestamp.logical,
+                    clockId: clock.id,
+                    type: entryType,
+                    metaData,
+                    payloadSize,
+                    metaBytes: preparedEntry.metaBytes,
+                    hashDigestBytes: preparedEntry.hashDigestBytes,
+                });
+                if (nativeEntry) {
+                    nativeEntries.push(nativeEntry);
+                }
+            }
+            return {
+                entries,
+                shallowEntries,
+                appendFacts,
+                nativeEntries,
+                nativeGraphUpdated: true,
+                nativeBlocksCommitted: true,
+            };
+        }
+        static createPlainAppendChainCommitOnly(properties) {
+            if (!properties.deferStore || properties.data.length !== 1) {
+                return undefined;
+            }
+            if (!(properties.identity instanceof Ed25519Keypair)) {
+                return undefined;
+            }
+            if (!properties.nativeGraph?.prepareEntryV0PlainEntryCommit &&
+                !properties.nativeGraph?.prepareEntryV0PlainEntryAndPut) {
+                return undefined;
+            }
+            const nexts = properties.meta?.next ?? [];
+            const nextHashes = [];
+            let gid = null;
+            if (nexts.length > 0) {
+                if (properties.meta?.gid) {
+                    throw new Error("Expecting '.meta.gid' property to be undefined if '.meta.next' is provided");
+                }
+                for (const next of nexts) {
+                    if (!next.hash) {
+                        throw new Error("Expecting hash to be defined to next entries");
+                    }
+                    nextHashes.push(next.hash);
+                    gid =
+                        gid == null
+                            ? next.meta.gid
+                            : next.meta.gid < gid
+                                ? next.meta.gid
+                                : gid;
+                }
+            }
+            else if (properties.meta?.gid) {
+                gid = properties.meta.gid;
+            }
+            else {
+                const createdGid = EntryV0.createGid(properties.meta?.gidSeed);
+                return isPromiseLike(createdGid)
+                    ? createdGid.then((resolvedGid) => EntryV0.finishPlainAppendChainCommitOnly(properties, nexts, nextHashes, resolvedGid))
+                    : EntryV0.finishPlainAppendChainCommitOnly(properties, nexts, nextHashes, createdGid);
+            }
+            return EntryV0.finishPlainAppendChainCommitOnly(properties, nexts, nextHashes, gid);
+        }
+        static finishPlainAppendChainCommitOnly(properties, nexts, nextHashes, gid) {
+            if (!properties.nativeGraph ||
+                !(properties.identity instanceof Ed25519Keypair)) {
+                return undefined;
+            }
+            const nativeGraph = properties.nativeGraph;
+            const identity = properties.identity;
+            const clocks = properties.meta?.clocks();
+            if (!clocks || clocks.length !== 1) {
+                throw new Error("Expected one clock per entry");
+            }
+            const clock = clocks[0];
+            for (const next of nexts) {
+                if (Timestamp.compare(next.meta.clock.timestamp, clock.timestamp) >= 0) {
+                    throw new Error("Expecting next(s) to happen before entry, got: " +
+                        next.meta.clock.timestamp +
+                        " > " +
+                        clock.timestamp);
+                }
+            }
+            const payloadData = properties.payloadDatas?.[0] ??
+                properties.encoding.encoder(properties.data[0]);
+            const entryType = properties.meta?.type ?? EntryType.APPEND;
+            const singleInput = {
+                clockId: identity.publicKey.bytes,
+                privateKey: identity.privateKey.privateKey,
+                publicKey: identity.publicKey.publicKey,
+                wallTime: clock.timestamp.wallTime,
+                logical: clock.timestamp.logical,
+                gid: gid,
+                next: nextHashes,
+                type: entryType,
+                metaData: properties.meta?.data,
+                payloadData,
+                includeMaterializationBytes: properties.includeMaterializationBytes,
+                includeAppendFactsBytes: properties.includeAppendFactsBytes,
+                trimLengthTo: properties.nativeTrimLengthTo,
+                resolveTrimmedEntries: properties.nativeTrimLengthTo == null ? undefined : false,
+            };
+            let nativeBlocksCommitted = false;
+            let nativeGraphUpdated = false;
+            const finishWithPreparedEntry = (preparedEntry) => {
+                if (!preparedEntry) {
+                    return undefined;
+                }
+                const payloadSize = payloadData.byteLength;
+                const shallowEntry = new ShallowEntry({
+                    hash: preparedEntry.cid,
+                    payloadSize,
+                    head: true,
+                    meta: new ShallowMeta({
+                        gid: gid,
+                        data: properties.meta?.data,
+                        clock,
+                        next: preparedEntry.next,
+                        type: entryType,
+                    }),
+                });
+                const appendFacts = {
+                    hash: preparedEntry.cid,
+                    gid: gid,
+                    next: preparedEntry.next,
+                    wallTime: clock.timestamp.wallTime,
+                    logical: clock.timestamp.logical,
+                    clockId: clock.id,
+                    type: entryType,
+                    metaData: properties.meta?.data,
+                    payloadSize,
+                    metaBytes: preparedEntry.metaBytes,
+                    hashDigestBytes: preparedEntry.hashDigestBytes,
+                };
+                let materialized;
+                const materializeEntry = (index = 0) => {
+                    if (index !== 0) {
+                        throw new Error("Prepared commit-only append only has one entry");
+                    }
+                    if (materialized) {
+                        return materialized;
+                    }
+                    const payload = new Payload({
+                        data: payloadData,
+                        value: properties.data[0],
+                        encoding: properties.encoding,
+                    });
+                    if (!preparedEntry.metaBytes ||
+                        !preparedEntry.payloadBytes ||
+                        !preparedEntry.signature ||
+                        !preparedEntry.signatureBytes) {
+                        const bytes = preparedEntry.bytes ??
+                            getSynchronousBlockBytes(properties.nativeBlockStore, preparedEntry.cid);
+                        if (!bytes) {
+                            throw new Error("Missing prepared entry bytes");
+                        }
+                        const entry = deserialize(bytes, Entry);
+                        entry.hash = preparedEntry.cid;
+                        entry.size = preparedEntry.byteLength;
+                        entry.createdLocally = true;
+                        entry._hashDigestBytes = preparedEntry.hashDigestBytes;
+                        Entry.prepareShallowEntry(entry, shallowEntry);
+                        entry.init({ encoding: properties.encoding });
+                        materialized = entry;
+                        return entry;
+                    }
+                    const signature = new SignatureWithKey({
+                        signature: preparedEntry.signature,
+                        publicKey: properties.identity.publicKey,
+                        prehash: 0,
+                    });
+                    const meta = new Meta({
+                        clock,
+                        gid: gid,
+                        type: entryType,
+                        data: properties.meta?.data,
+                        next: preparedEntry.next,
+                    });
+                    const entry = new EntryV0({
+                        meta: new DecryptedThing({
+                            data: preparedEntry.metaBytes,
+                            value: meta,
+                        }),
+                        payload: new DecryptedThing({
+                            data: preparedEntry.payloadBytes,
+                            value: payload,
+                        }),
+                        signatures: new Signatures({
+                            signatures: [
+                                new DecryptedThing({
+                                    data: preparedEntry.signatureBytes,
+                                    value: signature,
+                                }),
+                            ],
+                        }),
+                        createdLocally: true,
+                    });
+                    entry.hash = preparedEntry.cid;
+                    entry.size = preparedEntry.byteLength;
+                    entry._hashDigestBytes = preparedEntry.hashDigestBytes;
+                    Entry.prepareShallowEntry(entry, shallowEntry);
+                    entry.init({ encoding: properties.encoding });
+                    materialized = entry;
+                    return entry;
+                };
+                const preparedBlock = preparedEntry.bytes && !nativeBlocksCommitted
+                    ? Entry.preparedBlockFromBytes(preparedEntry.bytes, preparedEntry.cid)
+                    : undefined;
+                return {
+                    materializeEntry,
+                    materializeEntries: () => [materializeEntry(0)],
+                    blocks: preparedBlock ? [preparedBlock] : undefined,
+                    shallowEntries: [shallowEntry],
+                    appendFacts: [appendFacts],
+                    trimmedNativeEntries: preparedEntry.trimmedEntries,
+                    trimmedNativeEntryHashes: preparedEntry.trimmedEntryHashes,
+                    trimmedNativeBlocksDeleted: nativeBlocksCommitted,
+                    nativeGraphUpdated,
+                    nativeBlocksCommitted,
+                };
+            };
+            const prepareAndPutFallback = () => {
+                const nativePrepareAndPut = nativeGraph.prepareEntryV0PlainEntryAndPut;
+                const preparedEntryValue = nativePrepareAndPut
+                    ? nativePrepareAndPut.call(nativeGraph, {
+                        ...singleInput,
+                    })
+                    : undefined;
+                if (isPromiseLike(preparedEntryValue)) {
+                    return preparedEntryValue.then((preparedEntry) => {
+                        nativeGraphUpdated = !!preparedEntry && !!nativePrepareAndPut;
+                        return finishWithPreparedEntry(preparedEntry);
+                    });
+                }
+                nativeGraphUpdated = !!preparedEntryValue && !!nativePrepareAndPut;
+                return finishWithPreparedEntry(preparedEntryValue);
+            };
+            const nativeCommit = nativeGraph.prepareEntryV0PlainEntryCommit;
+            if (nativeCommit) {
+                const preparedEntryValue = nativeCommit.call(nativeGraph, singleInput, properties.nativeBlockStore);
+                if (isPromiseLike(preparedEntryValue)) {
+                    return preparedEntryValue.then((preparedEntry) => {
+                        if (preparedEntry) {
+                            nativeBlocksCommitted = true;
+                            nativeGraphUpdated = true;
+                            return finishWithPreparedEntry(preparedEntry);
+                        }
+                        return prepareAndPutFallback();
+                    });
+                }
+                if (preparedEntryValue) {
+                    nativeBlocksCommitted = true;
+                    nativeGraphUpdated = true;
+                    return finishWithPreparedEntry(preparedEntryValue);
+                }
+            }
+            return prepareAndPutFallback();
+        }
+        static async createPlainAppendChainBatch(properties) {
+            if (!properties.deferStore) {
+                return undefined;
+            }
+            if (!(properties.identity instanceof Ed25519Keypair)) {
+                return undefined;
+            }
+            const nativeEncoderValue = loadNativeEntryV0Encoder();
+            const nativeEncoder = isPromiseLike(nativeEncoderValue)
+                ? await nativeEncoderValue
+                : nativeEncoderValue;
+            if (!nativeEncoder?.prepareEntryV0PlainChain) {
+                return undefined;
+            }
+            const nexts = properties.meta?.next ?? [];
+            const nextHashes = [];
+            let gid = null;
+            if (nexts.length > 0) {
+                if (properties.meta?.gid) {
+                    throw new Error("Expecting '.meta.gid' property to be undefined if '.meta.next' is provided");
+                }
+                for (const next of nexts) {
+                    if (!next.hash) {
+                        throw new Error("Expecting hash to be defined to next entries");
+                    }
+                    nextHashes.push(next.hash);
+                    gid =
+                        gid == null
+                            ? next.meta.gid
+                            : next.meta.gid < gid
+                                ? next.meta.gid
+                                : gid;
+                }
+            }
+            else {
+                if (properties.meta?.gid) {
+                    gid = properties.meta.gid;
+                }
+                else {
+                    const createdGid = EntryV0.createGid(properties.meta?.gidSeed);
+                    gid = isPromiseLike(createdGid) ? await createdGid : createdGid;
+                }
+            }
+            const clocks = properties.meta?.clocks();
+            if (!clocks || clocks.length !== properties.data.length) {
+                throw new Error("Expected one clock per entry");
+            }
+            for (const next of nexts) {
+                if (Timestamp.compare(next.meta.clock.timestamp, clocks[0].timestamp) >= 0) {
+                    throw new Error("Expecting next(s) to happen before entry, got: " +
+                        next.meta.clock.timestamp +
+                        " > " +
+                        clocks[0].timestamp);
+                }
+            }
+            for (let i = 1; i < clocks.length; i++) {
+                if (Timestamp.compare(clocks[i - 1].timestamp, clocks[i].timestamp) >= 0) {
+                    throw new Error("Expecting generated clocks to increase across appendMany");
+                }
+            }
+            const entryType = properties.meta?.type ?? EntryType.APPEND;
+            const clockId = properties.identity.publicKey.bytes;
+            const privateKey = properties.identity.privateKey.privateKey;
+            const publicKey = properties.identity.publicKey.publicKey;
+            let nativeBlocksCommitted = false;
+            let nativeGraphUpdated = false;
+            let prepared;
+            let payloadDatas;
+            if (properties.data.length === 1) {
+                const clock = clocks[0];
+                const payloadData = properties.payloadDatas?.[0] ??
+                    properties.encoding.encoder(properties.data[0]);
+                const singleInput = {
+                    clockId,
+                    privateKey,
+                    publicKey,
+                    wallTime: clock.timestamp.wallTime,
+                    logical: clock.timestamp.logical,
+                    gid: gid,
+                    next: nextHashes,
+                    type: entryType,
+                    metaData: properties.meta?.data,
+                    payloadData,
+                };
+                const nativeCommit = properties.nativeGraph?.prepareEntryV0PlainEntryCommit;
+                const preparedEntryValue = nativeCommit
+                    ? nativeCommit.call(properties.nativeGraph, singleInput, properties.nativeBlockStore)
+                    : undefined;
+                const preparedEntry = isPromiseLike(preparedEntryValue)
+                    ? await preparedEntryValue
+                    : preparedEntryValue;
+                if (preparedEntry) {
+                    nativeBlocksCommitted = true;
+                    nativeGraphUpdated = true;
+                    prepared = [preparedEntry];
+                    payloadDatas = [payloadData];
+                }
+                else {
+                    const nativePrepareAndPut = properties.nativeGraph?.prepareEntryV0PlainEntryAndPut;
+                    const scalarPreparedEntryValue = nativePrepareAndPut
+                        ? nativePrepareAndPut.call(properties.nativeGraph, singleInput)
+                        : nativeEncoder.prepareEntryV0PlainEntry?.(singleInput);
+                    const scalarPreparedEntry = isPromiseLike(scalarPreparedEntryValue)
+                        ? await scalarPreparedEntryValue
+                        : scalarPreparedEntryValue;
+                    if (scalarPreparedEntry) {
+                        nativeGraphUpdated = !!nativePrepareAndPut;
+                        prepared = [scalarPreparedEntry];
+                        payloadDatas = [payloadData];
+                    }
+                }
+            }
+            if (!prepared) {
+                const wallTimes = new Array(properties.data.length);
+                const logicals = new Array(properties.data.length);
+                const metaDatas = new Array(properties.data.length);
+                if (properties.payloadDatas &&
+                    properties.payloadDatas.length !== properties.data.length) {
+                    throw new Error("Expected one payload data value per entry");
+                }
+                payloadDatas = properties.payloadDatas
+                    ? [...properties.payloadDatas]
+                    : new Array(properties.data.length);
+                for (let i = 0; i < properties.data.length; i++) {
+                    const clock = clocks[i];
+                    wallTimes[i] = clock.timestamp.wallTime;
+                    logicals[i] = clock.timestamp.logical;
+                    metaDatas[i] = properties.meta?.data;
+                    payloadDatas[i] ??= properties.encoding.encoder(properties.data[i]);
+                }
+                const nativePlainChainInput = {
+                    clockId,
+                    privateKey,
+                    publicKey,
+                    wallTimes,
+                    logicals,
+                    gid: gid,
+                    initialNext: nextHashes,
+                    type: entryType,
+                    metaDatas,
+                    payloadDatas,
+                };
+                const nativeCommit = properties.nativeGraph?.prepareEntryV0PlainChainCommit;
+                const preparedValue = nativeCommit
+                    ? nativeCommit.call(properties.nativeGraph, nativePlainChainInput, properties.nativeBlockStore)
+                    : undefined;
+                prepared = isPromiseLike(preparedValue)
+                    ? await preparedValue
+                    : preparedValue;
+                if (prepared) {
+                    nativeBlocksCommitted = true;
+                    nativeGraphUpdated = true;
+                }
+                else {
+                    const nativePrepareAndPut = properties.nativeGraph?.prepareEntryV0PlainChainAndPut;
+                    const preparedFallbackValue = nativePrepareAndPut
+                        ? nativePrepareAndPut.call(properties.nativeGraph, nativePlainChainInput)
+                        : nativeEncoder.prepareEntryV0PlainChain(nativePlainChainInput);
+                    prepared = isPromiseLike(preparedFallbackValue)
+                        ? await preparedFallbackValue
+                        : preparedFallbackValue;
+                    nativeGraphUpdated = !!nativePrepareAndPut;
+                }
+            }
+            const entries = [];
+            const blocks = [];
+            const shallowEntries = [];
+            const appendFacts = [];
+            const nativeEntries = [];
+            if (!payloadDatas) {
+                throw new Error("Expected payload data for prepared append chain");
+            }
+            for (let index = 0; index < prepared.length; index++) {
+                const preparedEntry = prepared[index];
+                const clock = clocks[index];
+                const meta = new Meta({
+                    clock,
+                    gid: gid,
+                    type: entryType,
+                    data: properties.meta?.data,
+                    next: preparedEntry.next,
+                });
+                const payloadSize = payloadDatas[index].byteLength;
+                const payload = properties.cachePreparedEntries === false
+                    ? undefined
+                    : new Payload({
+                        data: payloadDatas[index],
+                        value: properties.data[index],
+                        encoding: properties.encoding,
+                    });
+                const signature = properties.cachePreparedEntries === false
+                    ? undefined
+                    : new SignatureWithKey({
+                        signature: preparedEntry.signature,
+                        publicKey: properties.identity.publicKey,
+                        prehash: 0,
+                    });
+                const entry = new EntryV0({
+                    meta: new DecryptedThing({
+                        data: preparedEntry.metaBytes,
+                        value: meta,
+                    }),
+                    payload: new DecryptedThing({
+                        data: preparedEntry.payloadBytes,
+                        value: payload,
+                    }),
+                    signatures: new Signatures({
+                        signatures: [
+                            new DecryptedThing({
+                                data: preparedEntry.signatureBytes,
+                                value: signature,
+                            }),
+                        ],
+                    }),
+                    createdLocally: true,
+                });
+                const preparedBlock = preparedEntry.bytes && !nativeBlocksCommitted
+                    ? Entry.preparedBlockFromBytes(preparedEntry.bytes, preparedEntry.cid)
+                    : undefined;
+                if (properties.cachePreparedEntries === false) {
+                    entry.hash = preparedEntry.cid;
+                    entry.size = preparedEntry.byteLength;
+                }
+                else {
+                    if (!preparedEntry.bytes) {
+                        throw new Error("Missing prepared entry bytes");
+                    }
+                    entry.hash = Entry.prepareMultihashBytes(entry, preparedEntry.bytes, preparedEntry.cid);
+                }
+                entry._hashDigestBytes = preparedEntry.hashDigestBytes;
+                const shallowEntry = new ShallowEntry({
+                    hash: entry.hash,
+                    payloadSize,
+                    head: index === prepared.length - 1,
+                    meta: new ShallowMeta({
+                        gid: gid,
+                        data: properties.meta?.data,
+                        clock,
+                        next: preparedEntry.next,
+                        type: entryType,
+                    }),
+                });
+                const nativeEntry = nativeGraphUpdated && properties.cachePreparedEntries === false
+                    ? undefined
+                    : {
+                        hash: entry.hash,
+                        gid: gid,
+                        next: preparedEntry.next,
+                        type: entryType,
+                        head: index === prepared.length - 1,
+                        payloadSize,
+                        data: properties.meta?.data,
+                        clock: {
+                            timestamp: {
+                                wallTime: clock.timestamp.wallTime,
+                                logical: clock.timestamp.logical,
+                            },
+                        },
+                    };
+                if (properties.cachePreparedEntries !== false) {
+                    Entry.prepareShallowEntry(entry, shallowEntry);
+                    Entry.prepareNativeLogEntry(entry, nativeEntry);
+                }
+                if (properties.cachePreparedEntries !== false) {
+                    entry.init({ encoding: properties.encoding });
+                }
+                entries.push(entry);
+                if (preparedBlock) {
+                    blocks.push(preparedBlock);
+                }
+                shallowEntries.push(shallowEntry);
+                appendFacts.push({
+                    hash: entry.hash,
+                    gid: gid,
+                    next: preparedEntry.next,
+                    wallTime: clock.timestamp.wallTime,
+                    logical: clock.timestamp.logical,
+                    clockId: clock.id,
+                    type: entryType,
+                    metaData: properties.meta?.data,
+                    payloadSize,
+                    metaBytes: preparedEntry.metaBytes,
+                    hashDigestBytes: preparedEntry.hashDigestBytes,
+                });
+                if (nativeEntry) {
+                    nativeEntries.push(nativeEntry);
+                }
+            }
+            return {
+                entries,
+                blocks: blocks.length > 0 ? blocks : undefined,
+                shallowEntries,
+                appendFacts,
+                nativeEntries,
+                nativeGraphUpdated,
+                nativeBlocksCommitted,
+            };
         }
         static async create(properties) {
             if (!properties.encoding || !properties?.meta?.next) {
@@ -472,14 +1434,30 @@ let EntryV0 = (() => {
                     properties.meta?.gid ||
                         (await EntryV0.createGid(properties.meta?.gidSeed));
             }
+            const entryType = properties.meta?.type ?? EntryType.APPEND;
             const metadataEncrypted = await maybeEncrypt(new Meta({
                 clock,
                 gid: gid,
-                type: properties.meta?.type ?? EntryType.APPEND,
+                type: entryType,
                 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);
+            const nativeEncoder = properties.encryption
+                ? undefined
+                : await loadNativeEntryV0Encoder();
+            const nativePlainInput = nativeEncoder
+                ? {
+                    clockId: clock.id,
+                    wallTime: clock.timestamp.wallTime,
+                    logical: clock.timestamp.logical,
+                    gid: gid,
+                    next: nextHashes,
+                    type: entryType,
+                    metaData: properties.meta?.data,
+                    payloadData: payloadToSave.data,
+                }
+                : undefined;
             // Sign id, encrypted payload, clock, nexts, refs
             const entry = new EntryV0({
                 meta: metadataEncrypted,
@@ -487,11 +1465,14 @@ let EntryV0 = (() => {
                 signatures: undefined,
                 createdLocally: true,
             });
-            const signers = properties.signers || [
-                properties.identity.sign.bind(properties.identity),
-            ];
-            const signableBytes = entry.getSignableBytes();
-            let signatures = await Promise.all(signers.map((signer) => signer(signableBytes)));
+            const signableBytes = nativeEncoder && nativePlainInput
+                ? await nativeEncoder.encodeEntryV0Signable(nativePlainInput)
+                : entry.getSignableBytes();
+            let signatures = properties.signers
+                ? properties.signers.length === 1
+                    ? [await properties.signers[0](signableBytes)]
+                    : await Promise.all(properties.signers.map((signer) => signer(signableBytes)))
+                : [await properties.identity.sign(signableBytes)];
             signatures = signatures.sort((a, b) => compare(a.signature, b.signature));
             const encryptedSignatures = [];
             const encryptAllSignaturesWithSameKey = isMaybeEryptionPublicKey(properties.encryption?.receiver?.signatures);
@@ -508,8 +1489,36 @@ let EntryV0 = (() => {
             if (properties.canAppend && !(await properties.canAppend(entry))) {
                 throw new AccessError("Not allowed to append");
             }
+            let nativeStorage;
+            if (nativeEncoder &&
+                nativePlainInput &&
+                !properties.canAppend &&
+                signatures.length === 1 &&
+                signatures[0].publicKey instanceof Ed25519PublicKey) {
+                const storageInput = {
+                    ...nativePlainInput,
+                    signature: signatures[0].signature,
+                    signaturePublicKey: signatures[0].publicKey.publicKey,
+                    prehash: signatures[0].prehash,
+                };
+                nativeStorage = nativeEncoder.encodeEntryV0StorageWithCid
+                    ? await nativeEncoder.encodeEntryV0StorageWithCid(storageInput)
+                    : await (async () => {
+                        const storageBytes = await nativeEncoder.encodeEntryV0Storage(storageInput);
+                        return {
+                            bytes: storageBytes,
+                            cid: await nativeEncoder.calculateRawCidV1(storageBytes),
+                        };
+                    })();
+            }
             // Append hash
-            entry.hash = await Entry.toMultihash(properties.store, entry);
+            entry.hash = properties.deferStore
+                ? nativeStorage
+                    ? Entry.prepareMultihashBytes(entry, nativeStorage.bytes, nativeStorage.cid)
+                    : await Entry.prepareMultihash(entry)
+                : nativeStorage
+                    ? await Entry.toMultihashBytes(properties.store, entry, nativeStorage.bytes, nativeStorage.cid)
+                    : await Entry.toMultihash(properties.store, entry);
             entry.init({ encoding: properties.encoding });
             return entry;
         }