@agoric/internal 0.3.3-dev-b2bff24.0 → 0.3.3-dev-4054171.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/internal",
-  "version": "0.3.3-dev-b2bff24.0+b2bff24",
+  "version": "0.3.3-dev-4054171.0+4054171",
   "description": "Externally unsupported utilities internal to agoric-sdk",
   "type": "module",
   "main": "src/index.js",
@@ -20,7 +20,7 @@
     "lint:types": "tsc"
   },
   "dependencies": {
-    "@agoric/base-zone": "0.1.1-dev-b2bff24.0+b2bff24",
+    "@agoric/base-zone": "0.1.1-dev-4054171.0+4054171",
     "@endo/common": "^1.2.10",
     "@endo/compartment-mapper": "^1.6.0",
     "@endo/errors": "^1.2.10",
@@ -36,7 +36,7 @@
     "jessie.js": "^0.3.4"
   },
   "devDependencies": {
-    "@agoric/cosmic-proto": "0.4.1-dev-b2bff24.0+b2bff24",
+    "@agoric/cosmic-proto": "0.4.1-dev-4054171.0+4054171",
     "@endo/exo": "^1.5.9",
     "@endo/init": "^1.1.9",
     "@fast-check/ava": "^2.0.1",
@@ -63,5 +63,5 @@
   "typeCoverage": {
     "atLeast": 92.65
   },
-  "gitHead": "b2bff2406b336cd5e1dcd865c295bae93629e6c1"
+  "gitHead": "4054171a6a562a8bad1824b0151d103b8fe2f502"
 }

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);