@agoric/internal 0.4.0-u19.2 → 0.4.0-u20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/internal",
-  "version": "0.4.0-u19.2",
+  "version": "0.4.0-u20.0",
   "description": "Externally unsupported utilities internal to agoric-sdk",
   "type": "module",
   "main": "src/index.js",
@@ -20,23 +20,26 @@
     "lint:types": "tsc"
   },
   "dependencies": {
-    "@agoric/base-zone": "^0.1.1-u19.0",
-    "@endo/common": "^1.2.9",
-    "@endo/errors": "^1.2.9",
-    "@endo/far": "^1.1.10",
-    "@endo/init": "^1.1.8",
-    "@endo/marshal": "^1.6.3",
-    "@endo/pass-style": "^1.4.8",
-    "@endo/patterns": "^1.4.8",
-    "@endo/promise-kit": "^1.1.9",
-    "@endo/stream": "^1.2.9",
+    "@agoric/base-zone": "^0.1.1-u20.0",
+    "@endo/common": "^1.2.10",
+    "@endo/compartment-mapper": "^1.6.0",
+    "@endo/errors": "^1.2.10",
+    "@endo/far": "^1.1.11",
+    "@endo/init": "^1.1.9",
+    "@endo/marshal": "^1.6.4",
+    "@endo/nat": "^5.1.0",
+    "@endo/pass-style": "^1.5.0",
+    "@endo/patterns": "^1.5.0",
+    "@endo/promise-kit": "^1.1.10",
+    "@endo/stream": "^1.2.10",
     "anylogger": "^0.21.0",
     "jessie.js": "^0.3.4"
   },
   "devDependencies": {
-    "@agoric/cosmic-proto": "^0.5.0-u19.2",
-    "@endo/exo": "^1.5.8",
-    "@endo/init": "^1.1.8",
+    "@agoric/cosmic-proto": "^0.5.0-u20.0",
+    "@endo/exo": "^1.5.9",
+    "@endo/init": "^1.1.9",
+    "@fast-check/ava": "^2.0.1",
     "ava": "^5.3.0",
     "tsd": "^0.31.1"
   },
@@ -58,7 +61,7 @@
     "access": "public"
   },
   "typeCoverage": {
-    "atLeast": 93.04
+    "atLeast": 92.65
   },
-  "gitHead": "f0ae74b84cb6de3724bfdcd18b4bea7e8199dee1"
+  "gitHead": "8e4207fa19dabf76c1f91f8779b5b5b93570ecea"
 }

package/src/config.d.ts

@@ -14,10 +14,8 @@ export namespace BridgeId {
     let WALLET: "wallet";
 }
 export namespace CosmosInitKeyToBridgeId {
-    import vbankPort = BANK;
-    export { vbankPort };
-    import vibcPort = DIBC;
-    export { vibcPort };
+    let vbankPort: "bank";
+    let vibcPort: "dibc";
 }
 export namespace WalletName {
     let depositFacet: "depositFacet";

package/src/config.js

@@ -31,10 +31,12 @@ export const BridgeId = /** @type {const} */ ({
 });
 harden(BridgeId);
 
+/** @satisfies {Record<string, BridgeId>} */
 export const CosmosInitKeyToBridgeId = {
-  vbankPort: BridgeId.BANK,
-  vibcPort: BridgeId.DIBC,
+  vbankPort: 'bank',
+  vibcPort: 'dibc',
 };
+harden(CosmosInitKeyToBridgeId);
 
 export const WalletName = /** @type {const} */ ({
   depositFacet: 'depositFacet',

package/src/hex.d.ts

@@ -0,0 +1,15 @@
+export function makePortableHexCodec(): HexCodec;
+export function makeBufferishHexCodec(Bufferish: BufferishConstructor): HexCodec;
+export const encodeHex: (buf: Uint8Array) => string;
+export const decodeHex: (hex: string) => Uint8Array;
+export type HexCodec = {
+    encodeHex: (buf: Uint8Array) => string;
+    decodeHex: (hex: string) => Uint8Array;
+};
+/**
+ * is the portion of the Node.js Buffer API we need for hex conversion.
+ */
+export type BufferishConstructor = Pick<BufferConstructor, "from" | "isBuffer"> & {
+    prototype: Pick<Buffer, "toString"> & Uint8Array;
+};
+//# sourceMappingURL=hex.d.ts.map

package/src/hex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["hex.js"],"names":[],"mappings":"AAsCO,wCAFM,QAAQ,CAyBpB;AAgBM,iDAJI,oBAAoB,GAElB,QAAQ,CAoBpB;8BA7FmB,UAAU,KAAK,MAAM;8BACrB,MAAM,KAAK,UAAU;;eAD3B,CAAC,GAAG,EAAE,UAAU,KAAK,MAAM;eAC3B,CAAC,GAAG,EAAE,MAAM,KAAK,UAAU;;;;;mCA6D5B,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,UAAU,CAAC,GAAG;IACvD,SAAS,EAAE,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,UAAU,CAAC;CAClD"}

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

@@ -3,12 +3,11 @@ export * from "./debug.js";
 export * from "./errors.js";
 export * from "./js-utils.js";
 export * from "./method-tools.js";
+export * from "./metrics.js";
 export * from "./ses-utils.js";
+export * from "./tmpDir.js";
 export * from "./typeCheck.js";
 export * from "./typeGuards.js";
 export * from "./types-index.js";
 export { pureDataMarshaller } from "./marshal.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";
 //# sourceMappingURL=index.d.ts.map

package/src/index.js

@@ -8,13 +8,11 @@ export * from './errors.js';
 export * from './js-utils.js';
 export { pureDataMarshaller } from './marshal.js';
 export * from './method-tools.js';
+export * from './metrics.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,15 +1,40 @@
+/** For overriding TypeScript inferring the type of `true` as boolean. */
+export const TRUE: true;
 /**
- * @file Pure JavaScript utility functions that are compatible with but not
- *   dependent upon a hardened environment.
+ * @typedef {<O extends Record<string, unknown>>(
+ *   obj: O,
+ * ) => { [K in keyof O]: K extends string ? [K, O[K]] : never }[keyof O][]} 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 objectMapMutable<O extends Record<PropertyKey, any>, V>(obj: O, mapFn: <K extends keyof O>(value: O[K], key: K) => V): { [K in keyof O]: V; };
+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 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) => { [K in keyof O]: K extends string ? [K, O[K]] : never; }[keyof O][];
+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":"AAEA;;;GAGG;AAEH,2EAMG;AAkBI,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,iCANiC,CAAC,SAA3B,MAAM,CAAC,WAAW,EAAE,GAAG,CAAE,EAC1B,CAAC,OACH,CAAC,SACD,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,GAC3C,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,GAAE,CAKjC;AASM,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;uBAnGa,CAAC,OAAO,SAAS,EAAE,2DAAkB,MAAM,CAAC;6BAE5C,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC"}
+{"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,39 @@
  *   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,
+ * ) => { [K in keyof O]: K extends string ? [K, O[K]] : never }[keyof O][]} 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',
@@ -18,8 +51,6 @@ Object.freeze(logLevels);
 
 /** @typedef {Pick<Console, LogLevel>} LimitedConsole */
 
-const { entries, fromEntries } = Object;
-
 /**
  * Deep-copy a value by round-tripping it through JSON (which drops
  * function/symbol/undefined values and properties that are non-enumerable
@@ -32,11 +63,14 @@ const { entries, fromEntries } = Object;
 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: K, 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') {
@@ -51,18 +85,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);
 
-  return wasMapped ? Object.fromEntries(mappedEntries) : value;
+  if (!wasMapped) {
+    return value;
+  }
+
+  const mappedObj = fromTypedEntries(mappedEntries);
+  return /** @type {any} */ (mappedObj);
 };
 
 /**
@@ -74,23 +120,78 @@ 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));
 
 /**
- * @template {Record<PropertyKey, any>} O
- * @template V
+ * 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) => V} mapFn
- * @returns {{ [K in keyof O]: V }}
+ * @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, mapFn) => {
-  const newEntries = entries(obj).map(([k, v]) => [k, mapFn(v, k)]);
-  return /** @type {{ [K in keyof O]: V }} */ (fromEntries(newEntries));
+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);
+};
+
+/**
+ * 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;
 };
 
 /**
@@ -114,3 +215,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]),
+    )
+  );