@peerbit/log 1.0.2

package/lib/esm/entry.d.ts

@@ -0,0 +1,179 @@
+import { LamportClock as Clock } from "./clock.js";
+import { MaybeEncrypted, PublicSignKey, X25519PublicKey, SignatureWithKey, Ed25519PublicKey, Identity, Keychain, X25519Keypair } from "@peerbit/crypto";
+import { Encoding } from "./encoding.js";
+import { StringArray } from "./types.js";
+import { Blocks } from "@peerbit/blocks-interface";
+export type MaybeEncryptionPublicKey = X25519PublicKey | X25519PublicKey[] | Ed25519PublicKey | Ed25519PublicKey[] | undefined;
+export type EncryptionTemplateMaybeEncrypted = EntryEncryptionTemplate<MaybeEncryptionPublicKey, MaybeEncryptionPublicKey, MaybeEncryptionPublicKey | {
+    [key: string]: MaybeEncryptionPublicKey;
+}, // signature either all signature encrypted by same key, or each individually
+MaybeEncryptionPublicKey>;
+export interface EntryEncryption {
+    reciever: EncryptionTemplateMaybeEncrypted;
+    keypair: X25519Keypair;
+}
+export declare function toBufferLE(num: bigint, width: number): Uint8Array;
+export declare function toBigIntLE(buf: Uint8Array): bigint;
+export type CanAppend<T> = (canAppend: Entry<T>) => Promise<boolean> | boolean;
+export declare class Payload<T> {
+    data: Uint8Array;
+    encoding: Encoding<T>;
+    private _value?;
+    constructor(props: {
+        data: Uint8Array;
+        value?: T;
+        encoding: Encoding<T>;
+    });
+    equals(other: Payload<T>): boolean;
+    getValue(encoding?: Encoding<T>): T;
+}
+export interface EntryEncryptionTemplate<A, B, C, D> {
+    metadata: A;
+    payload: B;
+    signatures: C;
+    next: D;
+}
+export declare enum EntryType {
+    APPEND = 0,
+    CUT = 1
+}
+export declare class Metadata {
+    gid: string;
+    clock: Clock;
+    maxChainLength: bigint;
+    type: EntryType;
+    constructor(properties?: {
+        gid: string;
+        clock: Clock;
+        maxChainLength: bigint;
+        type: EntryType;
+    });
+}
+export declare class Signatures {
+    signatures: MaybeEncrypted<SignatureWithKey>[];
+    constructor(properties?: {
+        signatures: MaybeEncrypted<SignatureWithKey>[];
+    });
+    equals(other: Signatures): boolean;
+}
+export declare class Entry<T> implements EntryEncryptionTemplate<Metadata, Payload<T>, SignatureWithKey[], Array<string>> {
+    _metadata: MaybeEncrypted<Metadata>;
+    _payload: MaybeEncrypted<Payload<T>>;
+    _next: MaybeEncrypted<StringArray>;
+    _reserved: Uint8Array;
+    _signatures?: Signatures;
+    hash: string;
+    createdLocally?: boolean;
+    private _keychain?;
+    private _encoding?;
+    constructor(obj: {
+        payload: MaybeEncrypted<Payload<T>>;
+        signatures?: Signatures;
+        metadata: MaybeEncrypted<Metadata>;
+        next: MaybeEncrypted<StringArray>;
+        reserved?: Uint8Array;
+        hash?: string;
+        createdLocally?: boolean;
+    });
+    init(props: {
+        keychain?: Keychain;
+        encoding: Encoding<T>;
+    } | Entry<T>): Entry<T>;
+    get encoding(): Encoding<T>;
+    get metadata(): Metadata;
+    getMetadata(): Promise<Metadata>;
+    get gid(): string;
+    getGid(): Promise<string>;
+    getClock(): Promise<Clock>;
+    get maxChainLength(): bigint;
+    getMaxChainLength(): Promise<bigint>;
+    get payload(): Payload<T>;
+    getPayload(): Promise<Payload<T>>;
+    getPayloadValue(): Promise<T>;
+    get publicKeys(): PublicSignKey[];
+    getPublicKeys(): Promise<PublicSignKey[]>;
+    get next(): string[];
+    getNext(): Promise<string[]>;
+    /**
+     * Will only return signatures I can decrypt
+     * @returns signatures
+     */
+    get signatures(): SignatureWithKey[];
+    /**
+     * Will only return signatures I can decrypt
+     * @returns signatures
+     */
+    getSignatures(): Promise<SignatureWithKey[]>;
+    /**
+     * Will only verify signatures I can decrypt
+     * @returns true if all are verified
+     */
+    verifySignatures(): Promise<boolean>;
+    static toSignable(entry: Entry<any>): Uint8Array;
+    toSignable(): Uint8Array;
+    equals(other: Entry<T>): boolean;
+    delete(store: Blocks): Promise<void>;
+    static createGid(seed?: Uint8Array): Promise<string>;
+    static create<T>(properties: {
+        store: Blocks;
+        gid?: string;
+        type?: EntryType;
+        gidSeed?: Uint8Array;
+        data: T;
+        encoding?: Encoding<T>;
+        canAppend?: CanAppend<T>;
+        next?: Entry<T>[];
+        clock?: Clock;
+        encryption?: EntryEncryption;
+        identity: Identity;
+        signers?: ((data: Uint8Array) => Promise<SignatureWithKey> | SignatureWithKey)[];
+    }): Promise<Entry<T>>;
+    /**
+     * Get the multihash of an Entry.
+     * @example
+     * const multfihash = await Entry.toMultihash(store, entry)
+     * console.log(multihash)
+     * // "Qm...Foo"
+     */
+    static toMultihash<T>(store: Blocks, entry: Entry<T>): Promise<string>;
+    /**
+     * Create an Entry from a hash.
+     * @example
+     * const entry = await Entry.fromMultihash(store, "zd...Foo")
+     * console.log(entry)
+     * // { hash: "Zd...Foo", payload: "hello", next: [] }
+     */
+    static fromMultihash<T>(store: Blocks, hash: string, options?: {
+        timeout?: number;
+        replicate?: boolean;
+    }): Promise<Entry<T>>;
+    /**
+     * Compares two entries.
+     * @param {Entry} a
+     * @param {Entry} b
+     * @returns {number} 1 if a is greater, -1 is b is greater
+     */
+    static compare<T>(a: Entry<T>, b: Entry<T>): number;
+    /**
+     * Check if an entry equals another entry.
+     * @param {Entry} a
+     * @param {Entry} b
+     * @returns {boolean}
+     */
+    static isEqual<T>(a: Entry<T>, b: Entry<T>): boolean;
+    /**
+     * Check if an entry is a parent to another entry.
+     * @param {Entry} entry1 Entry to check
+     * @param {Entry} entry2 The parent Entry
+     * @returns {boolean}
+     */
+    static isDirectParent<T>(entry1: Entry<T>, entry2: Entry<T>): boolean;
+    /**
+     * Find entry's children from an Array of entries.
+     * Returns entry's children as an Array up to the last know child.
+     * @param {Entry} entry Entry for which to find the parents
+     * @param {Array<Entry<T>>} values Entries to search parents from
+     * @returns {Array<Entry<T>>}
+     */
+    static findDirectChildren<T>(entry: Entry<T>, values: Entry<T>[]): Entry<T>[];
+}