@agoric/internal 0.3.3-other-dev-3eb1a1d.0 → 0.3.3-other-dev-d15096d.0.d15096d

package/src/hex.js

@@ -0,0 +1,105 @@
+/**
+ * @typedef {object} HexCodec
+ * @property {(buf: Uint8Array) => string} encodeHex
+ * @property {(hex: string) => Uint8Array} decodeHex
+ */
+
+/** @type {string[]} */
+const encodings = Array.from({ length: 256 }, (_, b) =>
+  // Write the hex representation of the byte.
+  b.toString(16).padStart(2, '0'),
+);
+
+/**
+ * Create map entries for all four permutations of lowercase and uppercase
+ * transformations of the two hex digits per byte. The map is keyed by the hex
+ * string and the value is the byte value. This allows for fast lookups when
+ * decoding hex strings.
+ *
+ * @type {Map<string, number>}
+ */
+const decodings = new Map(
+  encodings.flatMap((hexdigits, b) => {
+    const lo = hexdigits.toLowerCase();
+    const UP = hexdigits.toUpperCase();
+    return [
+      [lo, b],
+      [`${lo[0]}${UP[1]}`, b],
+      [`${UP[0]}${lo[1]}`, b],
+      [UP, b],
+    ];
+  }),
+);
+
+/**
+ * Create a hex codec that is portable across standard JS environments.
+ *
+ * @returns {HexCodec}
+ */
+export const makePortableHexCodec = () => {
+  /** @type {HexCodec} */
+  const portableHexCodec = {
+    encodeHex: buf => Array.from(buf, b => encodings[b]).join(''),
+    decodeHex: hex => {
+      const inputLen = hex.length;
+      if (inputLen % 2 !== 0) {
+        throw new Error(`Invalid hex string: ${hex}`);
+      }
+      const buf = new Uint8Array(inputLen / 2);
+      for (let i = 0; i < inputLen; i += 2) {
+        const b = decodings.get(hex.slice(i, i + 2));
+        if (b === undefined) {
+          throw new Error(`Invalid hex string: ${hex}`);
+        }
+        // eslint-disable-next-line no-bitwise
+        buf[i >> 1] = b;
+      }
+      return buf;
+    },
+  };
+
+  return portableHexCodec;
+};
+
+/**
+ * @typedef {Pick<BufferConstructor, 'from' | 'isBuffer'> & {
+ *   prototype: Pick<Buffer, 'toString'> & Uint8Array;
+ * }} BufferishConstructor
+ *   is the portion of the Node.js Buffer API we need for hex conversion.
+ */
+
+/**
+ * Create a hex codec using parts of the Node.js Buffer API.
+ *
+ * @param {BufferishConstructor} Bufferish the object that implements the
+ *   necessary pieces of Buffer
+ * @returns {HexCodec}
+ */
+export const makeBufferishHexCodec = Bufferish => {
+  /** @type {HexCodec} */
+  const attenuatedBufferHexCodec = {
+    encodeHex: buf =>
+      (Bufferish.isBuffer?.(buf) ? buf : Bufferish.from(buf)).toString('hex'),
+    decodeHex: hex => {
+      const buf = Bufferish.from(hex, 'hex');
+
+      // Coerce to Uint8Array to avoid leaking the abstraction.
+      const u8a = new Uint8Array(
+        buf.buffer,
+        buf.byteOffset,
+        buf.byteLength / Uint8Array.BYTES_PER_ELEMENT,
+      );
+      return u8a;
+    },
+  };
+  return attenuatedBufferHexCodec;
+};
+
+/**
+ * Export a hex codec that can work with standard JS engines, but takes
+ * advantage of optimizations on some platforms (like Node.js's Buffer API).
+ */
+export const { encodeHex, decodeHex } =
+  typeof Buffer === 'undefined'
+    ? makePortableHexCodec()
+    : makeBufferishHexCodec(Buffer);

package/src/index.d.ts

@@ -1,13 +1,15 @@
+export * from "./cli-utils.js";
 export * from "./config.js";
 export * from "./debug.js";
 export * from "./errors.js";
 export * from "./js-utils.js";
 export * from "./method-tools.js";
+export * from "./metrics.js";
+export * from "./natural-sort.js";
 export * from "./ses-utils.js";
+export * from "./tmpDir.js";
 export * from "./typeCheck.js";
 export * from "./typeGuards.js";
 export * from "./types-index.js";
-export { objectMap } from "@endo/common/object-map.js";
-export { objectMetaMap } from "@endo/common/object-meta-map.js";
-export { fromUniqueEntries } from "@endo/common/from-unique-entries.js";
+export { pureDataMarshaller } from "./marshal/pure-data.js";
 //# sourceMappingURL=index.d.ts.map

package/src/index.js

@@ -2,18 +2,27 @@
 
 /// <reference types="ses" />
 
+// NOTE: Because @endo/bundle-source does not do tree-shaking (at least as of
+// September 2025), bundles for sources that import from '@agoric/internal' will
+// include each of these files even if none of their own exports are used.
+// To keep the size of bundles down, deep imports from @agoric/internal are
+// preferred.
+// HOWEVER, there are still occasional imports of '@agoric/internal', so be
+// judicious about what to include here!
+
+export * from './cli-utils.js';
 export * from './config.js';
 export * from './debug.js';
 export * from './errors.js';
 export * from './js-utils.js';
+export { pureDataMarshaller } from './marshal/pure-data.js';
 export * from './method-tools.js';
+export * from './metrics.js';
+export * from './natural-sort.js';
 export * from './ses-utils.js';
+export * from './tmpDir.js';
 export * from './typeCheck.js';
 export * from './typeGuards.js';
 
 // eslint-disable-next-line import/export -- just types
 export * from './types-index.js';
-
-export { objectMap } from '@endo/common/object-map.js';
-export { objectMetaMap } from '@endo/common/object-meta-map.js';
-export { fromUniqueEntries } from '@endo/common/from-unique-entries.js';

package/src/js-utils.d.ts

@@ -1,7 +1,44 @@
+/** For overriding TypeScript inferring the type of `true` as boolean. */
+export const TRUE: true;
+/**
+ * @typedef {<O extends Record<string, unknown>>(
+ *   obj: O,
+ * ) => Exclude<
+ *   { [K in keyof O]: K extends string ? [K, O[K]] : never }[keyof O],
+ *   undefined
+ * >[]} TypedEntries
+ */
+export const typedEntries: TypedEntries;
+/**
+ * @typedef {<
+ *   const Entries extends ReadonlyArray<readonly [PropertyKey, unknown]>,
+ * >(
+ *   entries: Entries,
+ * ) => { [Entry in Entries[number] as Entry[0]]: Entry[1] }} FromTypedEntries
+ */
+export const fromTypedEntries: FromTypedEntries;
+/**
+ * @typedef {<A extends unknown[], V>(
+ *   arr: A,
+ *   mapper: <K extends number>(el: A[K], idx: K, arr: A) => V,
+ * ) => V[]} TypedMap
+ */
+export const typedMap: TypedMap;
+export const logLevels: readonly ["debug", "log", "info", "warn", "error"];
 export function deepCopyJsonable<T>(value: T): T;
-export function deepMapObject(obj: object, mapper: (value: any, name: string, record: object) => any): object;
+export function deepMapObject<O extends Record<string, unknown>, M>(obj: O, mapper: <T extends Record<string, unknown>, K extends string & keyof T>(value: T[K], name: K, record: T) => T[K] | M): O | { [K_1 in keyof O]: K_1 extends string ? O[K_1] | M : never; };
+export function defineName<F extends Function>(name: string, fn: F): F;
+export function objectMapMutable<O extends Record<string, unknown>, M>(obj: O, mapper: <K extends keyof O>(value: O[K], key: K) => M): { [K in keyof O]: K extends string ? M : never; };
+export function partialMap<T, U>(arr: T[], mapOrDrop: (value: T, index: number, arr: T[]) => U | undefined | false): U[];
+export function provideLazyMap<K, V>(map: K extends WeakKey ? WeakMap<K, V> : Map<K, V>, key: K, makeValue: (key: K) => V): V;
 export function makeMeasureSeconds(currentTimeMillisec: () => number): <T>(fn: () => Promise<T>) => Promise<{
     result: T;
     duration: number;
 }>;
+export function unprefixedProperties<P extends string, K extends string, V>(obj: Record<`${P}${K}`, V>, prefix: P): Record<K, V>;
+export type TypedEntries = <O extends Record<string, unknown>>(obj: O) => Exclude<{ [K in keyof O]: K extends string ? [K, O[K]] : never; }[keyof O], undefined>[];
+export type FromTypedEntries = <const Entries extends ReadonlyArray<readonly [PropertyKey, unknown]>>(entries: Entries) => { [Entry in Entries[number] as Entry[0]]: Entry[1]; };
+export type TypedMap = <A extends unknown[], V>(arr: A, mapper: <K extends number>(el: A[K], idx: K, arr: A) => V) => V[];
+export type LogLevel = (typeof logLevels)[keyof readonly ["debug", "log", "info", "warn", "error"] & number];
+export type LimitedConsole = Pick<Console, LogLevel>;
 //# sourceMappingURL=js-utils.d.ts.map

package/src/js-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"js-utils.d.ts","sourceRoot":"","sources":["js-utils.js"],"names":[],"mappings":"AAgBO,iCAJM,CAAC,SACH,CAAC,GACC,CAAC,CAE4D;AAiDnE,mCAJI,MAAM,UACN,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,GAAG,GAC/C,MAAM,CAGuC;AASnD,wDAFI,MAAM,MAAM,IAIR,CAAC,MACH,MAAM,OAAO,CAAC,CAAC,CAAC,KACd,OAAO,CAAC;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAStD"}
+{"version":3,"file":"js-utils.d.ts","sourceRoot":"","sources":["js-utils.js"],"names":[],"mappings":"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"}

package/src/js-utils.js

@@ -5,6 +5,55 @@
  *   dependent upon a hardened environment.
  */
 
+const { defineProperty } = Object;
+
+/** For overriding TypeScript inferring the type of `true` as boolean. */
+export const TRUE = /** @type {const} */ (true);
+
+/**
+ * @typedef {<O extends Record<string, unknown>>(
+ *   obj: O,
+ * ) => Exclude<
+ *   { [K in keyof O]: K extends string ? [K, O[K]] : never }[keyof O],
+ *   undefined
+ * >[]} TypedEntries
+ */
+export const typedEntries = /** @type {TypedEntries} */ (Object.entries);
+
+/**
+ * @typedef {<
+ *   const Entries extends ReadonlyArray<readonly [PropertyKey, unknown]>,
+ * >(
+ *   entries: Entries,
+ * ) => { [Entry in Entries[number] as Entry[0]]: Entry[1] }} FromTypedEntries
+ */
+export const fromTypedEntries = /** @type {FromTypedEntries} */ (
+  Object.fromEntries
+);
+
+/**
+ * @typedef {<A extends unknown[], V>(
+ *   arr: A,
+ *   mapper: <K extends number>(el: A[K], idx: K, arr: A) => V,
+ * ) => V[]} TypedMap
+ */
+export const typedMap = /** @type {TypedMap} */ (
+  Function.prototype.call.bind(Array.prototype.map)
+);
+
+export const logLevels = /** @type {const} */ ([
+  'debug',
+  'log',
+  'info',
+  'warn',
+  'error',
+]);
+Object.freeze(logLevels);
+
+/** @typedef {(typeof logLevels)[keyof logLevels & number]} LogLevel */
+
+/** @typedef {Pick<Console, LogLevel>} LimitedConsole */
+
 /**
  * Deep-copy a value by round-tripping it through JSON (which drops
  * function/symbol/undefined values and properties that are non-enumerable
@@ -17,11 +66,14 @@
 export const deepCopyJsonable = value => JSON.parse(JSON.stringify(value));
 
 /**
- * @param {any} value
- * @param {string | undefined} name
- * @param {object | undefined} container
- * @param {(value: any, name: string, record: object) => any} mapper
- * @returns {any}
+ * @template {Record<PropertyKey, unknown>} O
+ * @template {string & keyof O} K
+ * @template M
+ * @param {O[K]} value
+ * @param {K | undefined} name
+ * @param {O | undefined} container
+ * @param {(value: O[K], name: string, record: O) => O[K] | M} mapper
+ * @returns {O[K] | M | { [K2 in keyof O[K]]: O[K][K2] | M }}
  */
 const deepMapObjectInternal = (value, name, container, mapper) => {
   if (container && typeof name === 'string') {
@@ -36,18 +88,30 @@ const deepMapObjectInternal = (value, name, container, mapper) => {
   }
 
   let wasMapped = false;
-  const mappedEntries = Object.entries(value).map(([innerName, innerValue]) => {
+  const valueObj = /** @type {Record<string, unknown>} */ (value);
+  /**
+   * @type {<T extends typeof value, K2 extends string & keyof T>(
+   *   entry: [K2, T[K2]],
+   * ) => [K2, T[K2] | M]}
+   */
+  const mapEntry = ([innerName, innerValue]) => {
     const mappedInnerValue = deepMapObjectInternal(
       innerValue,
       innerName,
-      value,
+      valueObj,
       mapper,
     );
     wasMapped ||= mappedInnerValue !== innerValue;
-    return [innerName, mappedInnerValue];
-  });
+    return [innerName, /** @type {any} */ (mappedInnerValue)];
+  };
+  const mappedEntries = typedEntries(valueObj).map(mapEntry);
+
+  if (!wasMapped) {
+    return value;
+  }
 
-  return wasMapped ? Object.fromEntries(mappedEntries) : value;
+  const mappedObj = fromTypedEntries(mappedEntries);
+  return /** @type {any} */ (mappedObj);
 };
 
 /**
@@ -59,12 +123,98 @@ const deepMapObjectInternal = (value, name, container, mapper) => {
  * When the property value is an object, it is sent to the mapper like any other
  * value, and then recursively traversed unless replaced with a distinct value.
  *
- * @param {object} obj
- * @param {(value: any, name: string, record: object) => any} mapper
- * @returns {object}
+ * @template {Record<string, unknown>} O
+ * @template M
+ * @param {O} obj
+ * @param {<T extends Record<string, unknown>, K extends string & keyof T>(
+ *   value: T[K],
+ *   name: K,
+ *   record: T,
+ * ) => T[K] | M} mapper
+ * @returns {O | { [K in keyof O]: K extends string ? O[K] | M : never }}
  */
 export const deepMapObject = (obj, mapper) =>
-  deepMapObjectInternal(obj, undefined, undefined, mapper);
+  /** @type {any} */ (deepMapObjectInternal(obj, undefined, undefined, mapper));
+
+/**
+ * Explicitly set a function's name, supporting use of arrow functions for which
+ * source text doesn't include a name and no initial name is set by
+ * NamedEvaluation
+ * https://tc39.es/ecma262/multipage/syntax-directed-operations.html#sec-runtime-semantics-namedevaluation
+ *
+ * `name` is the first parameter for better readability at call sites (e.g.,
+ * `return defineName('foo', () => { ... })`).
+ *
+ * @template {Function} F
+ * @param {string} name
+ * @param {F} fn
+ * @returns {F}
+ */
+export const defineName = (name, fn) =>
+  defineProperty(fn, 'name', { value: name });
+
+/**
+ * By analogy with how `Array.prototype.map` will map the elements of an array
+ * to transformed elements of an array of the same shape, `objectMapMutable`
+ * will do likewise for the enumerable string-keyed properties of an object.
+ *
+ * Unlike endo's `objectMap`, this function returns a non-hardened object.
+ *
+ * @template {Record<string, unknown>} O
+ * @template M
+ * @param {O} obj
+ * @param {<K extends keyof O>(value: O[K], key: K) => M} mapper
+ * @returns {{ [K in keyof O]: K extends string ? M : never }}
+ */
+export const objectMapMutable = (obj, mapper) => {
+  const oldEntries = typedEntries(obj);
+  /** @type {<K extends keyof O>(entry: [K, O[K]]) => [K, M]} */
+  const mapEntry = ([k, v]) => [k, mapper(v, k)];
+  const newEntries = typedMap(oldEntries, mapEntry);
+  const newObj = fromTypedEntries(newEntries);
+  return /** @type {any} */ (newObj);
+};
+
+/**
+ * Map the elements of an array to new values, skipping elements for which the
+ * mapping results in either `undefined` or `false`.
+ *
+ * @template T
+ * @template U
+ * @param {T[]} arr
+ * @param {(value: T, index: number, arr: T[]) => U | undefined | false} mapOrDrop
+ * @returns {U[]}
+ */
+export const partialMap = (arr, mapOrDrop) =>
+  arr.reduce((results, el, i, arrArg) => {
+    const result = mapOrDrop(el, i, arrArg);
+    if (result !== undefined && result !== false) {
+      results.push(result);
+    }
+    return results;
+  }, /** @type {U[]} */ ([]));
+
+/**
+ * Return the value from `map` associated with `key`. If there is not yet such a
+ * value, get one from `makeValue(key)` and update `map` before returning the
+ * new value.
+ *
+ * @template K
+ * @template V
+ * @param {K extends WeakKey ? WeakMap<K, V> : Map<K, V>} map
+ * @param {K} key
+ * @param {(key: K) => V} makeValue
+ * @returns {V}
+ */
+export const provideLazyMap = (map, key, makeValue) => {
+  const found = map.get(key);
+  if (found !== undefined || map.has(key)) {
+    return /** @type {V} */ (found);
+  }
+  const value = makeValue(key);
+  map.set(key, value);
+  return value;
+};
 
 /**
  * Returns a function that uses a millisecond-based current-time capability
@@ -87,3 +237,23 @@ export const makeMeasureSeconds = currentTimeMillisec => {
   };
   return measureSeconds;
 };
+
+/**
+ * Find all of an object's properties whose name starts with a prefix, and
+ * return a new object consisting of those properties without that prefix.
+ * Useful for filtering environment variables relevant to a particular purpose.
+ *
+ * @template {string} P
+ * @template {string} K
+ * @template V
+ * @param {Record<`${P}${K}`, V>} obj
+ * @param {P} prefix
+ */
+export const unprefixedProperties = (obj, prefix) =>
+  /** @type {Record<K, V>} */ (
+    fromTypedEntries(
+      typedEntries(obj)
+        .filter(([key]) => key.startsWith(prefix))
+        .map(([key, value]) => [key.slice(prefix.length), value]),
+    )
+  );

package/src/lib-chainStorage.d.ts

@@ -13,23 +13,12 @@
  */
 export function makeChainStorageRoot(handleStorageMessage: (message: StorageMessage) => any, rootPath: string, rootOptions?: {
     sequence?: boolean | undefined;
-} | undefined): import("@endo/exo").Guarded<{
+}): import("@endo/exo").Guarded<{
     getPath(): string;
-    /**
-     * @deprecated use getPath
-     * @type {() => Promise<VStorageKey>}
-     */
     getStoreKey(): Promise<VStorageKey>;
-    /**
-     * @type {(
-     *   name: string,
-     *   childNodeOptions?: { sequence?: boolean },
-     * ) => StorageNode}
-     */
     makeChildNode(name: string, childNodeOptions?: {
         sequence?: boolean;
     }): StorageNode;
-    /** @type {(value: string) => Promise<void>} */
     setValue(value: string): Promise<void>;
 }>;
 /**
@@ -37,38 +26,54 @@ export function makeChainStorageRoot(handleStorageMessage: (message: StorageMess
  * falling back to an inert object with the correct interface (but incomplete
  * behavior) when that is unavailable.
  *
- * @param {ERef<StorageNode?>} storageNodeRef
+ * @param {ERef<Remote<StorageNode> | null>} storageNodeRef
  * @param {string} childName
- * @returns {Promise<StorageNode>}
+ * @returns {Promise<Remote<StorageNode>>}
+ */
+export function makeStorageNodeChild(storageNodeRef: ERef<Remote<StorageNode> | null>, childName: string): Promise<Remote<StorageNode>>;
+/**
+ * @import {ERef} from '@endo/far';
+ * @import {Marshal, Passable} from '@endo/marshal';
+ * @import {Remote, ERemote, TypedPattern} from './types.js';
+ * @import {EMarshaller} from './marshal/wrap-marshaller.js';
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {Callback} from './types.js';
+ */
+/** @typedef {Marshal<unknown>} Marshaller */
+/** @typedef {Pick<Marshaller, 'fromCapData'>} Unserializer */
+/**
+ * Defined by vstorageStoreKey in vstorage.go
+ *
+ * @typedef VStorageKey
+ * @property {string} storeName
+ * @property {string} storeSubkey
+ * @property {string} dataPrefixBytes
+ * @property {string} [noDataValue]
+ */
+/**
+ * @template [T=unknown]
+ * @typedef StreamCell
+ * @property {string} blockHeight corresponding with the write of `values`
+ *   (decimal representation of a natural number)
+ * @property {T[]} values
  */
-export function makeStorageNodeChild(storageNodeRef: ERef<StorageNode | null>, childName: string): Promise<StorageNode>;
+/** @type {TypedPattern<StreamCell>} */
+export const StreamCellShape: TypedPattern<StreamCell>;
 export function isStreamCell(cell: any): cell is StreamCell;
-export function assertCapData(data: unknown): asserts data is import("@endo/marshal").CapData<string>;
 /** @type {(name: string) => void} */
 export const assertPathSegment: (name: string) => void;
-export function prepareChainStorageNode(zone: import("@agoric/base-zone").Zone): (messenger: import("./types.js").Callback<(message: StorageMessage) => any>, path: string, args_2?: {
+export function prepareChainStorageNode(zone: Zone): (messenger: Callback<(message: StorageMessage) => any>, path: string, args_2?: {
     sequence?: boolean | undefined;
 } | undefined) => import("@endo/exo").Guarded<{
     getPath(): string;
-    /**
-     * @deprecated use getPath
-     * @type {() => Promise<VStorageKey>}
-     */
     getStoreKey(): Promise<VStorageKey>;
-    /**
-     * @type {(
-     *   name: string,
-     *   childNodeOptions?: { sequence?: boolean },
-     * ) => StorageNode}
-     */
     makeChildNode(name: string, childNodeOptions?: {
         sequence?: boolean;
     }): StorageNode;
-    /** @type {(value: string) => Promise<void>} */
     setValue(value: string): Promise<void>;
 }>;
-export function makeSerializeToStorage(storageNode: ERef<StorageNode>, marshaller: ERef<Marshaller>): (value: PassableCap) => Promise<void>;
-export type Marshaller = ReturnType<typeof import("@endo/marshal").makeMarshal>;
+export function makeSerializeToStorage(storageNode: ERemote<StorageNode>, marshaller: ERemote<EMarshaller>): (value: Passable) => Promise<void>;
+export type Marshaller = Marshal<unknown>;
 export type Unserializer = Pick<Marshaller, "fromCapData">;
 /**
  * Defined by vstorageStoreKey in vstorage.go
@@ -81,7 +86,8 @@ export type VStorageKey = {
 };
 export type StreamCell<T = unknown> = {
     /**
-     * decimal representation of a natural number
+     * corresponding with the write of `values`
+     * (decimal representation of a natural number)
      */
     blockHeight: string;
     values: T[];
@@ -164,6 +170,13 @@ export type StorageMessage = {
     method: StorageUpdateEntriesMessageMethod;
     args: StorageUpdateEntriesMessageArgs;
 };
+import type { Remote } from './types.js';
 import type { ERef } from '@endo/far';
-import type { PassableCap } from '@endo/marshal';
+import type { TypedPattern } from './types.js';
+import type { Zone } from '@agoric/base-zone';
+import type { Callback } from './types.js';
+import type { ERemote } from './types.js';
+import type { EMarshaller } from './marshal/wrap-marshaller.js';
+import type { Passable } from '@endo/marshal';
+import type { Marshal } from '@endo/marshal';
 //# sourceMappingURL=lib-chainStorage.d.ts.map

package/src/lib-chainStorage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lib-chainStorage.d.ts","sourceRoot":"","sources":["lib-chainStorage.js"],"names":[],"mappings":"AAyPA;;;;;;;;;;;;GAYG;AACH,2DATW,CAAC,OAAO,EAAE,cAAc,KAAK,GAAG,YAGhC,MAAM;;;;IAhEX;;;OAGG;mBADa,OAAO,CAAC,WAAW,CAAC;IASpC;;;;;OAKG;wBAHQ,MAAM,qBACO;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GACtC,WAAW;IAYnB,+CAA+C;oBAA5B,MAAM,GAAK,OAAO,CAAC,IAAI,CAAC;GAqDhD;AAcD;;;;;;;;GAQG;AACH,qDAJW,KAAK,WAAW,OAAC,CAAC,aAClB,MAAM,GACJ,OAAO,CAAC,WAAW,CAAC,CAMhC;AApOM,mCAHI,GAAG,GACD,IAAI,IAAI,UAAU,CAOa;AASrC,oCAHI,OAAO,GACL,QAAQ,IAAI,IAAI,OAAO,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,CAQnE;AAmBD,qCAAqC;AACrC,gCADW,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAI/B;AAyCK,8CAFI,OAAO,mBAAmB,EAAE,IAAI,uDAwBxB,cAAc,KAAK,GAAG;;;;IAenC;;;OAGG;mBADa,OAAO,CAAC,WAAW,CAAC;IASpC;;;;;OAKG;wBAHQ,MAAM,qBACO;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GACtC,WAAW;IAYnB,+CAA+C;oBAA5B,MAAM,GAAK,OAAO,CAAC,IAAI,CAAC;GA0BhD;AA+DM,oDAJI,KAAK,WAAW,CAAC,cACjB,KAAK,UAAU,CAAC,GACd,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAQjD;yBA7Sa,UAAU,CAAC,cAAc,eAAe,EAAE,WAAW,CAAC;2BACtD,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC;;;;;eAM/B,MAAM;iBACN,MAAM;qBACN,MAAM;;;uBAKN,CAAC;;;;iBAED,MAAM;YACN,CAAC,EAAE;;;;;;;;;;;;;;;;cAcH,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC;;;;;aAC/B,MAAM,MAAM;;;;iBAEZ,MAAM,OAAO,CAAC,WAAW,CAAC;mBAC1B,CACT,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAC7B,WAAW;;;;;;;aA6CL,MAAM,OAAO,CAAC,MAAM,CAAC;;;;iBAErB,WAAW,CAAC,aAAa,CAAC;;;;;qBAC1B,MAAM,YAAY;;;;;4CAqBnB,KAAK,GACX,aAAa,GACb,KAAK,GACL,UAAU,GACV,SAAS,GACT,QAAQ,GACR,MAAM;;;;gDAGA,KAAK,GAAG,kBAAkB,GAAG,QAAQ;;;;mCAGrC,6BAA6B,GACnC,iCAAiC;;;;0CAG3B,CAAC,IAAI,EAAE,MAAM,CAAC;;;;2BAEd,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;;;;8CAErC,YAAY,EAAE;;;;6BAEd;IACJ,MAAM,EAAE,6BAA6B,CAAC;IACtC,IAAI,EAAE,2BAA2B,CAAC;CACnC,GACD;IACE,MAAM,EAAE,iCAAiC,CAAC;IAC1C,IAAI,EAAE,+BAA+B,CAAC;CACvC;0BA5Ie,WAAW;iCACJ,eAAe"}
+{"version":3,"file":"lib-chainStorage.d.ts","sourceRoot":"","sources":["lib-chainStorage.js"],"names":[],"mappings":"AAiPA;;;;;;;;;;;;GAYG;AACH,2DATW,CAAC,OAAO,EAAE,cAAc,KAAK,GAAG,YAGhC,MAAM,gBAEd;IAA8B,QAAQ;CAGxC;;mBAnEqB,OAAO,CAAC,WAAW,CAAC;wBAWzB,MAAM,qBACO;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GACtC,WAAW;oBAYA,MAAM,GAAK,OAAO,CAAC,IAAI,CAAC;GAqDhD;AAcD;;;;;;;;GAQG;AACH,qDAJW,KAAK,OAAO,WAAW,CAAC,GAAG,IAAI,CAAC,aAChC,MAAM,GACJ,OAAO,CAAC,OAAO,WAAW,CAAC,CAAC,CAMxC;AA3RD;;;;;;;GAOG;AAEH,6CAA6C;AAC7C,8DAA8D;AAE9D;;;;;;;;GAQG;AAEH;;;;;;GAMG;AAEH,uCAAuC;AACvC,8BADW,aAAa,UAAU,CAAC,CAIhC;AAwCI,mCAHI,GAAG,GACD,IAAI,IAAI,UAAU,CAOa;AAmB5C,qCAAqC;AACrC,gCADW,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAI/B;AAyCK,8CAFI,IAAI,kCAqBmB,cAAc,KAAK,GAAG;;;;mBAgBlC,OAAO,CAAC,WAAW,CAAC;wBAWzB,MAAM,qBACO;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GACtC,WAAW;oBAYA,MAAM,GAAK,OAAO,CAAC,IAAI,CAAC;GA0BhD;AA+DM,oDAJI,QAAQ,WAAW,CAAC,cACpB,QAAQ,WAAW,CAAC,GAClB,CAAC,KAAK,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAQ9C;yBAjSa,QAAQ,OAAO,CAAC;2BAChB,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC;;;;;eAM/B,MAAM;iBACN,MAAM;qBACN,MAAM;;;uBAKN,CAAC;;;;;iBAED,MAAM;YAEN,CAAC,EAAE;;;;;;;;;;;;;;;;cAoBH,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC;;;;;aAC/B,MAAM,MAAM;;;;iBAEZ,MAAM,OAAO,CAAC,WAAW,CAAC;mBAC1B,CACT,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAC7B,WAAW;;;;;;;aA8BL,MAAM,OAAO,CAAC,MAAM,CAAC;;;;iBAErB,WAAW,CAAC,aAAa,CAAC;;;;;qBAC1B,MAAM,YAAY;;;;;4CAqBnB,KAAK,GACX,aAAa,GACb,KAAK,GACL,UAAU,GACV,SAAS,GACT,QAAQ,GACR,MAAM;;;;gDAGA,KAAK,GAAG,kBAAkB,GAAG,QAAQ;;;;mCAGrC,6BAA6B,GACnC,iCAAiC;;;;0CAG3B,CAAC,IAAI,EAAE,MAAM,CAAC;;;;2BAEd,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;;;;8CAErC,YAAY,EAAE;;;;6BAEd;IACJ,MAAM,EAAE,6BAA6B,CAAC;IACtC,IAAI,EAAE,2BAA2B,CAAC;CACnC,GACD;IACE,MAAM,EAAE,iCAAiC,CAAC;IAC1C,IAAI,EAAE,+BAA+B,CAAC;CACvC;4BAtIwC,YAAY;0BAFrC,WAAW;kCAEc,YAAY;0BAErC,mBAAmB;8BACf,YAAY;6BAHS,YAAY;iCAC9B,8BAA8B;8BAFxB,eAAe;6BAAf,eAAe"}