@agoric/internal 0.2.2-pismo-dev-50dc068.0 → 0.3.0

package/src/method-tools.js

@@ -0,0 +1,110 @@
+// @ts-check
+import { isObject } from '@endo/marshal';
+
+/**
+ * @file method-tools use dynamic property lookup, which is not Jessie-compatible
+ */
+
+const { getPrototypeOf, create, fromEntries, getOwnPropertyDescriptors } =
+  Object;
+const { ownKeys, apply } = Reflect;
+
+/**
+ * Prioritize symbols as earlier than strings.
+ *
+ * @param {string|symbol} a
+ * @param {string|symbol} b
+ * @returns {-1 | 0 | 1}
+ */
+const compareStringified = (a, b) => {
+  if (typeof a === typeof b) {
+    const left = String(a);
+    const right = String(b);
+    // eslint-disable-next-line no-nested-ternary
+    return left < right ? -1 : left > right ? 1 : 0;
+  }
+  if (typeof a === 'symbol') {
+    assert(typeof b === 'string');
+    return -1;
+  }
+  assert(typeof a === 'string');
+  assert(typeof b === 'symbol');
+  return 1;
+};
+
+/**
+ * TODO Consolidate with the `getMethodNames` in `@endo/eventual-send`
+ *
+ * @template {PropertyKey} K
+ * @param {Record<K, any>} val
+ * @returns {K[]}
+ */
+export const getMethodNames = val => {
+  let layer = val;
+  const names = new Set(); // Set to deduplicate
+  while (layer !== null && layer !== Object.prototype) {
+    // be tolerant of non-objects
+    const descs = getOwnPropertyDescriptors(layer);
+    const ownNames = /** @type {K[]} */ (ownKeys(descs));
+    for (const name of ownNames) {
+      // In case a method is overridden by a non-method,
+      // test `val[name]` rather than `layer[name]`
+      if (typeof val[name] === 'function') {
+        names.add(name);
+      }
+    }
+    if (!isObject(val)) {
+      break;
+    }
+    layer = getPrototypeOf(layer);
+  }
+  return harden([...names].sort(compareStringified));
+};
+harden(getMethodNames);
+
+/**
+ * TODO This function exists only to ease the
+ * https://github.com/Agoric/agoric-sdk/pull/5970 transition, from all methods
+ * being own properties to methods being inherited from a common prototype.
+ * This transition breaks two patterns used in prior code: autobinding,
+ * and enumerating methods by enumerating own properties. For both, the
+ * preferred repairs are
+ *    * autobinding: Replace, for example,
+ *      `foo(obj.method)` with `foo(arg => `obj.method(arg))`. IOW, stop relying
+ *      on expressions like `obj.method` to extract a method still bound to the
+ *      state of `obj` because, for virtual and durable objects,
+ *      they no longer will after #5970.
+ *    * method enumeration: Replace, for example
+ *      `Reflect.ownKeys(obj)` with `getMethodNames(obj)`.
+ *
+ * Once all problematic cases have been converted in this manner, this
+ * `bindAllMethods` hack can and TODO should be deleted. However, we currently
+ * have no reliable static way to track down and fix all autobinding sites.
+ * For those objects that have not yet been fully repaired by the above two
+ * techniques, `bindAllMethods` creates an object that acts much like the
+ * pre-#5970 objects, with all their methods as instance-bound own properties.
+ * It does this by making a new object inheriting from `obj` where the new
+ * object has bound own methods overridding all the methods it would have
+ * inherited from `obj`.
+ *
+ * @template {Record<PropertyKey, any>} T
+ * @param {T} obj
+ * @returns {T}
+ */
+export const bindAllMethods = obj =>
+  harden(
+    create(
+      obj,
+      fromEntries(
+        getMethodNames(obj).map(name => [
+          name,
+          {
+            value: (/** @type {unknown[]} */ ...args) =>
+              apply(obj[name], obj, args),
+            enumerable: true,
+          },
+        ]),
+      ),
+    ),
+  );
+harden(bindAllMethods);

package/src/node/buffer-line-transform.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+/**
+ * @typedef {object} BufferLineTransformOptions
+ * @property {Buffer | string | number} [break] line break matcher for Buffer.indexOf() (default: 10)
+ * @property {BufferEncoding} [breakEncoding] if break is a string, the encoding to use
+ */
+export default class BufferLineTransform extends Transform {
+    /**
+     * The BufferLineTransform is reading String or Buffer content from a Readable stream
+     * and writing each line as a Buffer in object mode
+     *
+     * @param {import('node:stream').TransformOptions & BufferLineTransformOptions} [options]
+     */
+    constructor(options?: (import("stream").TransformOptions & BufferLineTransformOptions) | undefined);
+    _breakValue: string | number | Buffer;
+    _breakEncoding: BufferEncoding | undefined;
+    _breakLength: number;
+    /** @type {Array<Buffer>} */
+    _chunks: Array<Buffer>;
+    /**
+     * @override
+     * @param {any} chunk
+     * @param {BufferEncoding | 'buffer'} encoding
+     * @param {import('node:stream').TransformCallback} cb
+     */
+    override _transform(chunk: any, encoding: BufferEncoding | 'buffer', cb: import('node:stream').TransformCallback): void;
+    /** @param {Buffer} line */
+    _writeItem(line: Buffer): void;
+}
+export type BufferLineTransformOptions = {
+    /**
+     * line break matcher for Buffer.indexOf() (default: 10)
+     */
+    break?: string | number | Buffer | undefined;
+    /**
+     * if break is a string, the encoding to use
+     */
+    breakEncoding?: BufferEncoding | undefined;
+};
+import { Transform } from "stream";
+//# sourceMappingURL=buffer-line-transform.d.ts.map

package/src/node/buffer-line-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-line-transform.d.ts","sourceRoot":"","sources":["buffer-line-transform.js"],"names":[],"mappings":";AAKA;;;;GAIG;AAEH;IACE;;;;;OAKG;IACH,oGAuBC;IAhBC,sCAAmC;IACnC,2CAAmC;IAWnC,qBAA+B;IAE/B,4BAA4B;IAC5B,SADW,MAAM,MAAM,CAAC,CACP;IAGnB;;;;;OAKG;IACH,2BAJW,GAAG,YACH,cAAc,GAAG,QAAQ,MACzB,OAAO,aAAa,EAAE,iBAAiB,QAgDjD;IAeD,2BAA2B;IAC3B,iBADY,MAAM,QAOjB;CACF"}

package/src/node/buffer-line-transform.js

@@ -0,0 +1,119 @@
+/* global Buffer */
+/* eslint-disable no-underscore-dangle */
+
+import { Transform } from 'node:stream';
+
+/**
+ * @typedef {object} BufferLineTransformOptions
+ * @property {Buffer | string | number} [break] line break matcher for Buffer.indexOf() (default: 10)
+ * @property {BufferEncoding} [breakEncoding] if break is a string, the encoding to use
+ */
+
+export default class BufferLineTransform extends Transform {
+  /**
+   * The BufferLineTransform is reading String or Buffer content from a Readable stream
+   * and writing each line as a Buffer in object mode
+   *
+   * @param {import('node:stream').TransformOptions & BufferLineTransformOptions} [options]
+   */
+  constructor(options) {
+    const {
+      break: breakValue,
+      breakEncoding,
+      ...transformOptions
+    } = options || {};
+    super({ ...transformOptions, readableObjectMode: true });
+    this._breakValue = breakValue || 10;
+    this._breakEncoding = breakEncoding;
+
+    /** @type {number} */
+    let breakLength;
+    if (!breakValue || typeof breakValue === 'number') {
+      breakLength = 1;
+    } else if (Buffer.isBuffer(breakValue)) {
+      breakLength = breakValue.length;
+    } else {
+      breakLength = Buffer.from(breakValue, breakEncoding).length;
+    }
+    this._breakLength = breakLength;
+
+    /** @type {Array<Buffer>} */
+    this._chunks = [];
+  }
+
+  /**
+   * @override
+   * @param {any} chunk
+   * @param {BufferEncoding | 'buffer'} encoding
+   * @param {import('node:stream').TransformCallback} cb
+   */
+  _transform(chunk, encoding, cb) {
+    try {
+      /** @type {Buffer} */
+      let buf =
+        Buffer.isBuffer(chunk) || encoding === 'buffer'
+          ? chunk
+          : Buffer.from(chunk, encoding);
+
+      // In case the break value is more than a single byte, it may span
+      // multiple chunks. Since Node doesn't provide a way to get partial
+      // search result, fallback to a less optimal early concatenation
+      if (this._breakLength > 1 && this._chunks.length) {
+        buf = Buffer.concat([/** @type {Buffer} */ (this._chunks.pop()), buf]);
+      }
+
+      while (buf.length) {
+        const offset = buf.indexOf(this._breakValue, 0, this._breakEncoding);
+
+        /** @type {number} */
+        let endOffset;
+        if (offset >= 0) {
+          endOffset = offset + this._breakLength;
+          if (this._chunks.length) {
+            const concatLength = this._chunks.reduce(
+              (acc, { length }) => acc + length,
+              endOffset,
+            );
+            this._writeItem(
+              Buffer.concat(
+                [...this._chunks.splice(0, this._chunks.length), buf],
+                concatLength,
+              ),
+            );
+          } else {
+            this._writeItem(buf.subarray(0, endOffset));
+          }
+        } else {
+          endOffset = buf.length;
+          this._chunks.push(buf);
+        }
+        buf = buf.subarray(endOffset);
+      }
+      cb();
+    } catch (err) {
+      cb(/** @type {any} */ (err)); // invalid data type;
+    }
+  }
+
+  /**
+   * @override
+   * @param {import('node:stream').TransformCallback} cb
+   */
+  _flush(cb) {
+    if (this._chunks.length) {
+      this._writeItem(
+        Buffer.concat(this._chunks.splice(0, this._chunks.length)),
+      );
+    }
+    cb();
+  }
+
+  /** @param {Buffer} line */
+  _writeItem(line) {
+    if (this.readableEncoding) {
+      this.push(line.toString(this.readableEncoding), this.readableEncoding);
+    } else {
+      this.push(line);
+    }
+  }
+}

package/src/node/createBundles.d.ts

@@ -0,0 +1,4 @@
+export function createBundlesFromAbsolute(sourceBundles: any): Promise<void>;
+export function createBundles(sourceBundles: any, dirname?: string): Promise<void>;
+export function extractProposalBundles(dirProposalBuilder: any, dirname?: string): Promise<void>;
+//# sourceMappingURL=createBundles.d.ts.map

package/src/node/createBundles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBundles.d.ts","sourceRoot":"","sources":["createBundles.js"],"names":[],"mappings":"AAUO,6EAyBN;AAEM,mFAMN;AAEM,iGAkCN"}

package/src/node/createBundles.js

@@ -0,0 +1,80 @@
+// Use modules not prefixed with `node:` since some deploy scripts may
+// still be running in esm emulation
+import path from 'path';
+import { spawnSync } from 'child_process';
+import { createRequire } from 'module';
+
+const { Fail, quote: q } = assert;
+const BUNDLE_SOURCE_PROGRAM = 'bundle-source';
+const req = createRequire(import.meta.url);
+
+export const createBundlesFromAbsolute = async sourceBundles => {
+  const prog = req.resolve(`.bin/${BUNDLE_SOURCE_PROGRAM}`);
+
+  const cacheToArgs = new Map();
+  for (const [srcPath, bundlePath] of sourceBundles) {
+    const cache = path.dirname(bundlePath);
+    const base = path.basename(bundlePath);
+
+    const match = base.match(/^bundle-(.*)\.js$/);
+    if (!match) {
+      throw Fail`${q(bundlePath)} is not 'DIR/bundle-NAME.js'`;
+    }
+    const bundle = match[1];
+
+    const args = cacheToArgs.get(cache) || ['--to', cache];
+    args.push(srcPath, bundle);
+    cacheToArgs.set(cache, args);
+  }
+
+  for (const args of cacheToArgs.values()) {
+    console.log(BUNDLE_SOURCE_PROGRAM, ...args);
+    const { status } = spawnSync(prog, args, { stdio: 'inherit' });
+    status === 0 ||
+      Fail`${q(BUNDLE_SOURCE_PROGRAM)} failed with status ${q(status)}`;
+  }
+};
+
+export const createBundles = async (sourceBundles, dirname = '.') => {
+  const absBundleSources = sourceBundles.map(([srcPath, bundlePath]) => [
+    req.resolve(srcPath, { paths: [dirname] }),
+    path.resolve(dirname, bundlePath),
+  ]);
+  return createBundlesFromAbsolute(absBundleSources);
+};
+
+export const extractProposalBundles = async (
+  dirProposalBuilder,
+  dirname = '.',
+) => {
+  const toBundle = new Map();
+
+  await Promise.all(
+    dirProposalBuilder.map(async ([dir, proposalBuilder]) => {
+      const home = path.resolve(dirname, dir);
+      const publishRef = x => x;
+      const install = async (src, bundleName) => {
+        if (bundleName) {
+          const bundlePath = path.resolve(home, bundleName);
+          const srcPath = req.resolve(src, { paths: [home] });
+          if (toBundle.has(bundlePath)) {
+            const oldSrc = toBundle.get(bundlePath);
+            oldSrc === srcPath ||
+              Fail`${q(bundlePath)} already installed as ${q(
+                oldSrc,
+              )}, also given ${q(srcPath)}`;
+          }
+          toBundle.set(bundlePath, srcPath);
+        }
+      };
+      return proposalBuilder({ publishRef, install });
+    }),
+  );
+
+  return createBundlesFromAbsolute(
+    [...toBundle.entries()].map(([bundlePath, srcPath]) => [
+      srcPath,
+      bundlePath,
+    ]),
+  );
+};

package/src/node/fs-stream.d.ts

@@ -0,0 +1,8 @@
+export function fsStreamReady(stream: import("fs").ReadStream | import("fs").WriteStream): Promise<void>;
+export function makeFsStreamWriter(filePath: string | undefined | null): Promise<{
+    write: (data: any) => Promise<void>;
+    flush: () => Promise<void>;
+    close: () => Promise<void>;
+} | undefined>;
+export type FsStreamWriter = NonNullable<Awaited<ReturnType<typeof makeFsStreamWriter>>>;
+//# sourceMappingURL=fs-stream.d.ts.map

package/src/node/fs-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-stream.d.ts","sourceRoot":"","sources":["fs-stream.js"],"names":[],"mappings":"AAQO,sCAHI,OAAO,IAAI,EAAE,UAAU,GAAG,OAAO,IAAI,EAAE,WAAW,GAChD,QAAQ,IAAI,CAAC,CAgCtB;AAQG,6CADK,MAAM,GAAG,SAAS,GAAG,IAAI;;;;eA2DpC;6BA5Da,YAAY,QAAQ,WAAW,yBAAyB,CAAC,CAAC,CAAC"}

package/src/node/fs-stream.js

@@ -0,0 +1,105 @@
+import { createWriteStream } from 'node:fs';
+import { open } from 'node:fs/promises';
+import { makeAggregateError } from '../utils.js';
+
+/**
+ * @param {import("fs").ReadStream | import("fs").WriteStream} stream
+ * @returns {Promise<void>}
+ */
+export const fsStreamReady = stream =>
+  new Promise((resolve, reject) => {
+    if (stream.destroyed) {
+      reject(Error('Stream already destroyed'));
+      return;
+    }
+
+    if (!stream.pending) {
+      resolve();
+      return;
+    }
+
+    const onReady = () => {
+      cleanup(); // eslint-disable-line no-use-before-define
+      resolve();
+    };
+
+    /** @param {Error} err */
+    const onError = err => {
+      cleanup(); // eslint-disable-line no-use-before-define
+      reject(err);
+    };
+
+    const cleanup = () => {
+      stream.off('ready', onReady);
+      stream.off('error', onError);
+    };
+
+    stream.on('ready', onReady);
+    stream.on('error', onError);
+  });
+
+const noPath = /** @type {import('fs').PathLike} */ (
+  /** @type {unknown} */ (undefined)
+);
+
+/** @typedef {NonNullable<Awaited<ReturnType<typeof makeFsStreamWriter>>>} FsStreamWriter */
+/** @param {string | undefined | null} filePath */
+export const makeFsStreamWriter = async filePath => {
+  if (!filePath) {
+    return undefined;
+  }
+
+  const handle = await open(filePath, 'a');
+
+  const stream = createWriteStream(noPath, { fd: handle.fd });
+  await fsStreamReady(stream);
+
+  let flushed = Promise.resolve();
+  let closed = false;
+
+  const write = async data => {
+    if (closed) {
+      throw Error('Stream closed');
+    }
+
+    /** @type {Promise<void>} */
+    const written = new Promise((resolve, reject) => {
+      stream.write(data, err => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+    flushed = flushed.then(
+      () => written,
+      async err =>
+        Promise.reject(
+          written.then(
+            () => err,
+            writtenError => makeAggregateError([err, writtenError]),
+          ),
+        ),
+    );
+    return written;
+  };
+
+  const flush = async () => {
+    await flushed;
+    await handle.sync().catch(err => {
+      if (err.code === 'EINVAL') {
+        return;
+      }
+      throw err;
+    });
+  };
+
+  const close = async () => {
+    closed = true;
+    await flush();
+    stream.close();
+  };
+
+  return harden({ write, flush, close });
+};

package/src/node/shutdown.d.ts

@@ -0,0 +1,6 @@
+export function makeFreshShutdown(verbose?: boolean): {
+    registerShutdown: (thunk: any) => () => void;
+};
+export function makeCachedShutdown(...args: any[]): any;
+export { makeCachedShutdown as makeShutdown };
+//# sourceMappingURL=shutdown.d.ts.map

package/src/node/shutdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown.d.ts","sourceRoot":"","sources":["shutdown.js"],"names":[],"mappings":"AAKO;;EA+DN;AAGM,wDAON"}

package/src/node/shutdown.js

@@ -0,0 +1,81 @@
+import process from 'node:process';
+import anylogger from 'anylogger';
+
+const console = anylogger('shutdown');
+
+export const makeFreshShutdown = (verbose = true) => {
+  const shutdownThunks = new Set();
+
+  let shuttingDown = false;
+  /** @type {NodeJS.SignalsListener & NodeJS.BeforeExitListener} */
+  const shutdown = code => {
+    const sig = typeof code === 'string' && code.startsWith('SIG');
+    const isSigInt = code === 'SIGINT';
+    if (sig) {
+      process.exitCode = 98;
+    }
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    // Allow an explicit exit to terminate the process.
+    process.off('SIGINT', shutdown);
+    process.off('SIGTERM', shutdown);
+    process.off('beforeExit', shutdown);
+    // eslint-disable-next-line no-use-before-define
+    process.off('uncaughtException', uncaughtShutdown);
+    verbose && console.error(`Shutting down cleanly...`);
+    const shutdowners = [...shutdownThunks.keys()];
+    shutdownThunks.clear();
+    Promise.allSettled(
+      [...shutdowners].map(t => Promise.resolve(isSigInt).then(t)),
+    )
+      .then(statuses => {
+        for (const status of statuses) {
+          if (status.status === 'rejected') {
+            verbose && console.warn(status.reason);
+          }
+        }
+        verbose && console.warn('Process terminated!');
+      })
+      .catch(error => verbose && console.warn('Error shutting down', error))
+      .finally(() => {
+        // Let `beforeExit` exit cleanly
+        if (!(code >= 0)) {
+          process.exit();
+        }
+      });
+  };
+
+  const uncaughtShutdown = e => {
+    console.error(e);
+    shutdown(-1);
+  };
+
+  // gracefully shut down the thunks on process exit
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', shutdown);
+  process.on('beforeExit', shutdown);
+  process.on('uncaughtException', uncaughtShutdown);
+
+  return {
+    registerShutdown: thunk => {
+      shutdownThunks.add(thunk);
+      return () => {
+        shutdownThunks.delete(thunk);
+      };
+    },
+  };
+};
+
+let cachedShutdown = null;
+export const makeCachedShutdown = (...args) => {
+  // It's possible our caller has specified different arguments.
+  // Since they control verbosity only, first-one-wins is acceptable.
+  if (!cachedShutdown) {
+    cachedShutdown = makeFreshShutdown(...args);
+  }
+  return cachedShutdown;
+};
+
+export { makeCachedShutdown as makeShutdown };

package/src/priority-senders.d.ts

@@ -0,0 +1,31 @@
+/** @type {(namespace: string) => string} */
+export const normalizeSenderNamespace: (namespace: string) => string;
+export function makePrioritySendersManager(sendersNode: ERef<import("./lib-chainStorage.js").StorageNode>): {
+    /**
+     * @param {string} rawNamespace
+     * @param {string} address
+     * @returns {Promise<void>}
+     */
+    add: (rawNamespace: string, address: string) => Promise<void>;
+    /**
+     * @param {string} rawNamespace
+     * @param {string} address
+     * @returns {Promise<void>}
+     */
+    remove: (rawNamespace: string, address: string) => Promise<void>;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    /**
+     * @param {string} rawNamespace
+     * @param {string} address
+     * @returns {Promise<void>}
+     */
+    add: (rawNamespace: string, address: string) => Promise<void>;
+    /**
+     * @param {string} rawNamespace
+     * @param {string} address
+     * @returns {Promise<void>}
+     */
+    remove: (rawNamespace: string, address: string) => Promise<void>;
+}>;
+export type PrioritySendersManager = ReturnType<typeof makePrioritySendersManager>;
+//# sourceMappingURL=priority-senders.d.ts.map

package/src/priority-senders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"priority-senders.d.ts","sourceRoot":"","sources":["priority-senders.js"],"names":[],"mappings":"AAMA,4CAA4C;AAC5C,mDADuB,MAAM,KAAK,MAAM,CAMtC;AAQK;IAoCH;;;;OAIG;wBAHQ,MAAM,WACN,MAAM,KACJ,QAAQ,IAAI,CAAC;IAe1B;;;;OAIG;2BAHQ,MAAM,WACN,MAAM,KACJ,QAAQ,IAAI,CAAC;;IArB1B;;;;OAIG;wBAHQ,MAAM,WACN,MAAM,KACJ,QAAQ,IAAI,CAAC;IAe1B;;;;OAIG;2BAHQ,MAAM,WACN,MAAM,KACJ,QAAQ,IAAI,CAAC;GAuB7B;qCAGa,WAAW,iCAAiC,CAAC"}