@holochain/client 0.20.0-rc.0 → 0.20.1

package/lib/utils/dna-holo-hash-map.js

@@ -0,0 +1,235 @@
+import flatMap from "lodash-es/flatMap.js";
+import { HoloHashMap } from "./holo-hash-map.js";
+/**
+ * A Map of DnaHash to HoloHashMap.
+ *
+ * i.e. A Map of DnaHash to a Map of HoloHash to a value.
+ *
+ * @param initialEntries - Optional array of `[[DnaHash, HoloHash], value]` to insert into the map.
+ *
+ * @public
+ */
+export class DnaHoloHashMap {
+    _dnaMap = new HoloHashMap();
+    constructor(initialEntries) {
+        if (initialEntries) {
+            for (const [[dnaHash, key], value] of initialEntries) {
+                this.set([dnaHash, key], value);
+            }
+        }
+    }
+    /**
+     * Gets the value associated with a [DnaHash, HoloHash] key pair.
+     *
+     * @param key - Array of [DnaHash, HoloHash]
+     * @returns The value if found, undefined otherwise
+     */
+    get([dnaHash, key]) {
+        return this._dnaMap.get(dnaHash)
+            ? this._dnaMap.get(dnaHash)?.get(key)
+            : undefined;
+    }
+    /**
+     * Checks if a [DnaHash, HoloHash] key pair exists in the map.
+     *
+     * @param cellKey - Array of [DnaHash, HoloHash] to check
+     * @returns True if the key exists, false otherwise
+     */
+    has([dnaHash, key]) {
+        const map = this._dnaMap.get(dnaHash);
+        return map ? map.has(key) : false;
+    }
+    /**
+     * Sets a value for a [DnaHash, HoloHash] key pair.
+     *
+     * @param key - Tuple of [DnaHash, HoloHash]
+     * @param value - The value to store
+     * @returns This map instance for chaining
+     */
+    set([dnaHash, key], value) {
+        const map = this._dnaMap.get(dnaHash);
+        if (map === undefined) {
+            this._dnaMap.set(dnaHash, new HoloHashMap([[key, value]]));
+        }
+        else {
+            map.set(key, value);
+        }
+        return this;
+    }
+    /**
+     * Removes all entries from the map.
+     */
+    clear() {
+        this._dnaMap.clear();
+    }
+    /**
+     * Deletes an entry from the map. If this was the last entry for a DNA, the DNA entry is also removed.
+     *
+     * @param key - Array of [DnaHash, HoloHash] to delete
+     * @returns True if the DNA entry was deleted (last entry for that DNA), false otherwise
+     */
+    delete([dnaHash, key]) {
+        const map = this._dnaMap.get(dnaHash);
+        if (map) {
+            const wasDeleted = map.delete(key);
+            if (wasDeleted && Array.from(map.keys()).length === 0) {
+                this._dnaMap.delete(dnaHash);
+            }
+            return wasDeleted;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * Returns all [DnaHash, HoloHash] key pairs in the map.
+     *
+     * @returns Array of all key tuples
+     */
+    keys() {
+        const dnaHashes = Array.from(this._dnaMap.keys());
+        return flatMap(dnaHashes, (dnaHash) => {
+            const cell = this._dnaMap.get(dnaHash);
+            const keys = cell ? Array.from(cell.keys()) : [];
+            return keys.map((key) => [dnaHash, key]);
+        });
+    }
+    /**
+     * Returns all values in the map.
+     *
+     * @returns Array of all values
+     */
+    values() {
+        return this.keys().map((dnaKey) => this.get(dnaKey));
+    }
+    /**
+     * Returns all entries as [[DnaHash, HoloHash], value] Arrays.
+     *
+     * @returns Array of all entries
+     */
+    entries() {
+        return this.keys().map((dnaKey) => [dnaKey, this.get(dnaKey)]);
+    }
+    /**
+     * Creates a new DnaHoloHashMap containing only entries that match the filter predicate.
+     *
+     * @param fn - Predicate function to test each value
+     * @returns A new filtered map
+     */
+    filter(fn) {
+        const entries = this.entries();
+        const mappedValues = entries.filter(([, v]) => fn(v));
+        return new DnaHoloHashMap(mappedValues);
+    }
+    /**
+     * Creates a new DnaHoloHashMap with values transformed by the mapping function.
+     *
+     * @param fn - Function to transform each value
+     * @returns A new mapped map
+     */
+    map(fn) {
+        const entries = this.entries();
+        const mappedValues = entries.map(([id, v]) => [id, fn(v)]);
+        return new DnaHoloHashMap(mappedValues);
+    }
+    /**
+     * Returns all HoloHash keys for a specific DNA.
+     *
+     * @param dnaHash - The DNA hash to query
+     * @returns Array of HoloHash keys for this DNA
+     */
+    keysForDna(dnaHash) {
+        const map = this._dnaMap.get(dnaHash);
+        return map ? Array.from(map.keys()) : [];
+    }
+    /**
+     * Returns all values for a specific DNA.
+     *
+     * @param dnaHash - The DNA hash to query
+     * @returns Array of values for this DNA
+     */
+    valuesForDna(dnaHash) {
+        const map = this._dnaMap.get(dnaHash);
+        return map ? Array.from(map.values()) : [];
+    }
+    /**
+     * Returns all [HoloHash, value] entries for a specific DNA.
+     *
+     * @param dnaHash - The DNA hash to query
+     * @returns Array of entries for this DNA
+     */
+    entriesForDna(dnaHash) {
+        const map = this._dnaMap.get(dnaHash);
+        return map ? Array.from(map.entries()) : [];
+    }
+    /**
+     * Removes all entries for a specific DNA.
+     *
+     * @param dnaHash - The DNA hash to clear
+     */
+    clearForDna(dnaHash) {
+        const map = this._dnaMap.get(dnaHash);
+        if (map !== undefined) {
+            map.clear();
+            this._dnaMap.set(dnaHash, map);
+        }
+    }
+    /**
+     * The number of DNA entries in the map.
+     *
+     * @returns The number of unique DNAs
+     */
+    get size() {
+        return this._dnaMap.size;
+    }
+}
+/**
+ * @public
+ */
+export class DnaAgentPubKeyMap extends DnaHoloHashMap {
+}
+/**
+ * @public
+ */
+export class DnaDnaHashMap extends DnaHoloHashMap {
+}
+/**
+ * @public
+ */
+export class DnaWasmHashMap extends DnaHoloHashMap {
+}
+/**
+ * @public
+ */
+export class DnaEntryHashMap extends DnaHoloHashMap {
+}
+/**
+ * @public
+ */
+export class DnaActionHashMap extends DnaHoloHashMap {
+}
+/**
+ * @public
+ */
+export class DnaAnyDhtHashMap extends DnaHoloHashMap {
+}
+/**
+ * @public
+ */
+export class DnaExternalHashMap extends DnaHoloHashMap {
+}
+/**
+ * @public
+ */
+export class DnaDhtOpHashMap extends DnaHoloHashMap {
+}
+/**
+ * @public
+ */
+export class DnaWarrantHashMap extends DnaHoloHashMap {
+}
+/**
+ * @public
+ */
+export class CellMap extends DnaAgentPubKeyMap {
+}

package/lib/utils/hash-parts.d.ts

@@ -1,17 +1,20 @@
-import { ActionHash, AgentPubKey, EntryHash } from "../types.js";
+import { HoloHash, HoloHashType } from "../types.js";
 /**
- * Hash type labels and their 3 byte values (forming the first 3 bytes of hash).
+ * Hash type labels mapped to their 3 byte values (forming the first 3 bytes of hash).
  *
  * From https://github.com/holochain/holochain/blob/develop/crates/holo_hash/src/hash_type/primitive.rs
  *
  * @public
  */
 export declare const HASH_TYPE_PREFIX: {
-    Agent: Uint8Array;
-    Entry: Uint8Array;
-    Dna: Uint8Array;
-    Action: Uint8Array;
-    External: Uint8Array;
+    agent: Uint8Array<ArrayBuffer>;
+    entry: Uint8Array<ArrayBuffer>;
+    dhtop: Uint8Array<ArrayBuffer>;
+    warrant: Uint8Array<ArrayBuffer>;
+    dna: Uint8Array<ArrayBuffer>;
+    action: Uint8Array<ArrayBuffer>;
+    wasm: Uint8Array<ArrayBuffer>;
+    external: Uint8Array<ArrayBuffer>;
 };
 /**
  * Get hash type (initial 3 bytes) from a hash.
@@ -23,7 +26,7 @@ export declare const HASH_TYPE_PREFIX: {
  *
  * @public
  */
-export declare function sliceHashType(hash: AgentPubKey | EntryHash | ActionHash): Uint8Array;
+export declare function sliceHashType(hash: HoloHash): Uint8Array;
 /**
  * Get core hash from a Holochain hash (32 bytes).
  *
@@ -34,7 +37,7 @@ export declare function sliceHashType(hash: AgentPubKey | EntryHash | ActionHash
  *
  * @public
  */
-export declare function sliceCore32(hash: AgentPubKey | EntryHash | ActionHash): Uint8Array;
+export declare function sliceCore32(hash: HoloHash): Uint8Array;
 /**
  * Get DHT location (last 4 bytes) from a hash.
  *
@@ -45,7 +48,7 @@ export declare function sliceCore32(hash: AgentPubKey | EntryHash | ActionHash):
  *
  * @public
  */
-export declare function sliceDhtLocation(hash: AgentPubKey | EntryHash | ActionHash): Uint8Array;
+export declare function sliceDhtLocation(hash: HoloHash): Uint8Array;
 /**
  * Generate DHT location (last 4 bytes) from a core hash (middle 32 bytes).
  *
@@ -57,6 +60,17 @@ export declare function sliceDhtLocation(hash: AgentPubKey | EntryHash | ActionH
  * @public
  */
 export declare function dhtLocationFrom32(hashCore: Uint8Array): Uint8Array;
+/**
+ * Get hash type of a hash, by reading the first 3 bytes.
+ *
+ * From https://github.com/holochain/holochain/blob/develop/crates/holo_hash/src/hash_type/primitive.rs
+ *
+ * @param hash - The full 39 byte hash.
+ * @returns The HashType
+ *
+ * @public
+ */
+export declare function getHashType(hash: HoloHash): HoloHashType;
 /**
  * Generate full hash from a core hash (middle 32 bytes) and hash type label.
  *
@@ -68,4 +82,16 @@ export declare function dhtLocationFrom32(hashCore: Uint8Array): Uint8Array;
  *
  * @public
  */
-export declare function hashFrom32AndType(hashCore: AgentPubKey | EntryHash | ActionHash, hashType: "Agent" | "Entry" | "Dna" | "Action" | "External"): Uint8Array;
+export declare function hashFrom32AndType(hashCore: HoloHash, hashType: HoloHashType): Uint8Array;
+/**
+ * Generate full hash from some data content and hash type label.
+ *
+ * From https://github.com/holochain/holochain/blob/develop/crates/holo_hash/src/hash_type/primitive.rs
+ *
+ * @param content - The data to hash.
+ * @param hashType - The type of the hash.
+ * @returns The full 39 byte hash.
+ *
+ * @public
+ */
+export declare function hashFromContentAndType(content: any, hashType: HoloHashType): Uint8Array;

package/lib/utils/hash-parts.js

@@ -1,21 +1,37 @@
+import { encode } from "@msgpack/msgpack";
+import { HoloHashType } from "../types.js";
 import blake2b from "@bitgo/blake2b";
+import isEqual from "lodash-es/isEqual.js";
 const HASH_TYPE_START = 0;
 const HASH_TYPE_BYTE_LENGTH = 3;
 const CORE_HASH_BYTE_LENGTH = 32;
 const DHT_LOCATION_BYTE_LENGTH = 4;
+const HASH_TYPE_PREFIX_U8 = {
+    [HoloHashType.Agent]: [132, 32, 36],
+    [HoloHashType.Entry]: [132, 33, 36],
+    [HoloHashType.DhtOp]: [132, 36, 36],
+    [HoloHashType.Warrant]: [132, 44, 36],
+    [HoloHashType.Dna]: [132, 45, 36],
+    [HoloHashType.Action]: [132, 41, 36],
+    [HoloHashType.Wasm]: [132, 42, 36],
+    [HoloHashType.External]: [132, 47, 36],
+};
 /**
- * Hash type labels and their 3 byte values (forming the first 3 bytes of hash).
+ * Hash type labels mapped to their 3 byte values (forming the first 3 bytes of hash).
  *
  * From https://github.com/holochain/holochain/blob/develop/crates/holo_hash/src/hash_type/primitive.rs
  *
  * @public
  */
 export const HASH_TYPE_PREFIX = {
-    Agent: Uint8Array.from([132, 32, 36]),
-    Entry: Uint8Array.from([132, 33, 36]),
-    Dna: Uint8Array.from([132, 45, 36]),
-    Action: Uint8Array.from([132, 41, 36]),
-    External: Uint8Array.from([132, 47, 36]),
+    [HoloHashType.Agent]: Uint8Array.from(HASH_TYPE_PREFIX_U8[HoloHashType.Agent]),
+    [HoloHashType.Entry]: Uint8Array.from(HASH_TYPE_PREFIX_U8[HoloHashType.Entry]),
+    [HoloHashType.DhtOp]: Uint8Array.from(HASH_TYPE_PREFIX_U8[HoloHashType.DhtOp]),
+    [HoloHashType.Warrant]: Uint8Array.from(HASH_TYPE_PREFIX_U8[HoloHashType.Warrant]),
+    [HoloHashType.Dna]: Uint8Array.from(HASH_TYPE_PREFIX_U8[HoloHashType.Dna]),
+    [HoloHashType.Action]: Uint8Array.from(HASH_TYPE_PREFIX_U8[HoloHashType.Action]),
+    [HoloHashType.Wasm]: Uint8Array.from(HASH_TYPE_PREFIX_U8[HoloHashType.Wasm]),
+    [HoloHashType.External]: Uint8Array.from(HASH_TYPE_PREFIX_U8[HoloHashType.External]),
 };
 /**
  * Get hash type (initial 3 bytes) from a hash.
@@ -82,6 +98,24 @@ export function dhtLocationFrom32(hashCore) {
     });
     return out;
 }
+/**
+ * Get hash type of a hash, by reading the first 3 bytes.
+ *
+ * From https://github.com/holochain/holochain/blob/develop/crates/holo_hash/src/hash_type/primitive.rs
+ *
+ * @param hash - The full 39 byte hash.
+ * @returns The HashType
+ *
+ * @public
+ */
+export function getHashType(hash) {
+    const hashTypeBytes = Array.from(hash.slice(0, 3));
+    const res = Object.entries(HASH_TYPE_PREFIX_U8).find(([, val]) => isEqual(val, hashTypeBytes));
+    if (res === undefined) {
+        throw new Error("First 3 bytes of hash do not match any known HashType");
+    }
+    return res[0];
+}
 /**
  * Generate full hash from a core hash (middle 32 bytes) and hash type label.
  *
@@ -100,3 +134,23 @@ export function hashFrom32AndType(hashCore, hashType) {
         ...dhtLocationFrom32(hashCore),
     ]);
 }
+/**
+ * Generate full hash from some data content and hash type label.
+ *
+ * From https://github.com/holochain/holochain/blob/develop/crates/holo_hash/src/hash_type/primitive.rs
+ *
+ * @param content - The data to hash.
+ * @param hashType - The type of the hash.
+ * @returns The full 39 byte hash.
+ *
+ * @public
+ */
+export function hashFromContentAndType(content, hashType) {
+    const hashCore = new Uint8Array(32);
+    blake2b(hashCore.length).update(encode(content)).digest(hashCore);
+    return Uint8Array.from([
+        ...HASH_TYPE_PREFIX[hashType],
+        ...hashCore,
+        ...dhtLocationFrom32(hashCore),
+    ]);
+}

package/lib/utils/holo-hash-map.d.ts

@@ -0,0 +1,247 @@
+import { ActionHash, ActionHashB64, AgentPubKey, AgentPubKeyB64, AnyDhtHash, AnyDhtHashB64, DhtOpHash, DhtOpHashB64, DnaHash, DnaHashB64, EntryHash, EntryHashB64, ExternalHash, ExternalHashB64, HoloHash, HoloHashB64, WarrantHash, WarrantHashB64, WasmHash, WasmHashB64 } from "../types.js";
+/**
+ * A Map of HoloHashB64 to a value.
+ *
+ * @param initialEntries - Optional array of [key, value] pairs to insert into the map.
+ *
+ * @public
+ */
+export declare class HoloHashB64Map<K extends HoloHashB64, V> extends Map<K, V> {
+    constructor(initialEntries?: Array<[K, V]>);
+}
+/**
+ * @public
+ */
+export declare class AgentPubKeyB64Map<V> extends HoloHashB64Map<AgentPubKeyB64, V> {
+}
+/**
+ * @public
+ */
+export declare class DnaHashB64Map<V> extends HoloHashB64Map<DnaHashB64, V> {
+}
+/**
+ * @public
+ */
+export declare class WasmHashB64Map<V> extends HoloHashB64Map<WasmHashB64, V> {
+}
+/**
+ * @public
+ */
+export declare class EntryHashB64Map<V> extends HoloHashB64Map<EntryHashB64, V> {
+}
+/**
+ * @public
+ */
+export declare class ActionHashB64Map<V> extends HoloHashB64Map<ActionHashB64, V> {
+}
+/**
+ * @public
+ */
+export declare class AnyDhtHashB64Map<V> extends HoloHashB64Map<AnyDhtHashB64, V> {
+}
+/**
+ * @public
+ */
+export declare class ExternalHashB64Map<V> extends HoloHashB64Map<ExternalHashB64, V> {
+}
+/**
+ * @public
+ */
+export declare class DhtOpHashB64Map<V> extends HoloHashB64Map<DhtOpHashB64, V> {
+}
+/**
+ * @public
+ */
+export declare class WarrantHashB64Map<V> extends HoloHashB64Map<WarrantHashB64, V> {
+}
+/**
+ * A Map of HoloHash to a value.
+ *
+ * @param initialEntries - Optional array of [key, value] pairs to insert into the map.
+ *
+ * @public
+ */
+export declare class HoloHashMap<K extends HoloHash, V> implements Map<K, V> {
+    private _map;
+    constructor(initialEntries?: Array<[K, V]>);
+    /**
+     * Removes all entries from the map.
+     */
+    clear(): void;
+    /**
+     * Returns an iterator of values in the map.
+     *
+     * @returns An iterator of all values
+     */
+    values(): MapIterator<V>;
+    /**
+     * Checks if a key exists in the map.
+     *
+     * @param key - The HoloHash key to check
+     * @returns True if the key exists, false otherwise
+     */
+    has(key: K): boolean;
+    /**
+     * Gets the value associated with a key.
+     *
+     * @param key - The HoloHash key
+     * @returns The value if found, undefined otherwise
+     */
+    get(key: K): V | undefined;
+    /**
+     * Sets a key-value pair in the map.
+     *
+     * @param key - The HoloHash key
+     * @param value - The value to store
+     * @returns This map instance for chaining
+     */
+    set(key: K, value: V): this;
+    /**
+     * Deletes an entry from the map.
+     *
+     * @param key - The HoloHash key to delete
+     * @returns True if the entry was deleted, false if it didn't exist
+     */
+    delete(key: K): boolean;
+    /**
+     * Returns an iterator of keys in the map.
+     *
+     * @returns An iterator of all HoloHash keys
+     */
+    keys(): MapIterator<K>;
+    /**
+     * Returns an iterator of [key, value] pairs.
+     *
+     * @returns An iterator of all entries
+     */
+    entries(): MapIterator<[K, V]>;
+    /**
+     * Executes a callback function for each entry in the map.
+     *
+     * @param callbackfn - Function to execute for each entry
+     * @param thisArg - Optional value to use as 'this' when executing the callback
+     */
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    get [Symbol.toStringTag](): string;
+    /**
+     * The number of entries in the map.
+     *
+     * @returns The size of the map
+     */
+    get size(): number;
+    private _encodeKey;
+    private _decodeKey;
+}
+/**
+ * @public
+ */
+export declare class AgentPubKeyMap<V> extends HoloHashMap<AgentPubKey, V> {
+}
+/**
+ * @public
+ */
+export declare class DnaHashMap<V> extends HoloHashMap<DnaHash, V> {
+}
+/**
+ * @public
+ */
+export declare class WasmHashMap<V> extends HoloHashMap<WasmHash, V> {
+}
+/**
+ * @public
+ */
+export declare class EntryHashMap<V> extends HoloHashMap<EntryHash, V> {
+}
+/**
+ * @public
+ */
+export declare class ActionHashMap<V> extends HoloHashMap<ActionHash, V> {
+}
+/**
+ * @public
+ */
+export declare class AnyDhtHashMap<V> extends HoloHashMap<AnyDhtHash, V> {
+}
+/**
+ * @public
+ */
+export declare class ExternalHashMap<V> extends HoloHashMap<ExternalHash, V> {
+}
+/**
+ * @public
+ */
+export declare class DhtOpHashMap<V> extends HoloHashMap<DhtOpHash, V> {
+}
+/**
+ * @public
+ */
+export declare class WarrantHashMap<V> extends HoloHashMap<WarrantHash, V> {
+}
+/**
+ * A HoloHashMap that will fetch and store a value if it is not found in a 'get' call.
+ *
+ * @param fetchValue - A function that takes a key and fetches its value.
+ * @param initialEntries - Optional array of [key, value] pairs to insert into the map.
+ *
+ * @public
+ */
+export declare class LazyHoloHashMap<K extends HoloHash, V> extends HoloHashMap<K, V> {
+    protected fetchValue: (key: K) => V | undefined;
+    constructor(fetchValue: (key: K) => V | undefined, initialEntries?: Array<[K, V]>);
+    /**
+     *
+     * Get a value for a key.
+     *
+     * If no value for a key is found, it is fetched, inserted into the Map, then returned.
+     *
+     * @param key - HoloHash key
+     * @returns value if found
+     */
+    get(key: K): V | undefined;
+}
+/**
+ * @public
+ */
+export declare class LazyAgentPubKeyMap<V> extends LazyHoloHashMap<AgentPubKey, V> {
+}
+/**
+ * @public
+ */
+export declare class LazyDnaHashMap<V> extends LazyHoloHashMap<DnaHash, V> {
+}
+/**
+ * @public
+ */
+export declare class LazyWasmHashMap<V> extends LazyHoloHashMap<WasmHash, V> {
+}
+/**
+ * @public
+ */
+export declare class LazyEntryHashMap<V> extends LazyHoloHashMap<EntryHash, V> {
+}
+/**
+ * @public
+ */
+export declare class LazyActionHashMap<V> extends LazyHoloHashMap<ActionHash, V> {
+}
+/**
+ * @public
+ */
+export declare class LazyAnyDhtHashMap<V> extends LazyHoloHashMap<AnyDhtHash, V> {
+}
+/**
+ * @public
+ */
+export declare class LazyExternalHashMap<V> extends LazyHoloHashMap<ExternalHash, V> {
+}
+/**
+ * @public
+ */
+export declare class LazyDhtOpHashMap<V> extends LazyHoloHashMap<DhtOpHash, V> {
+}
+/**
+ * @public
+ */
+export declare class LazyWarrantHashMap<V> extends LazyHoloHashMap<WarrantHash, V> {
+}