@agoric/internal 0.2.2-dev-4874362.0 → 0.2.2-dev-5933241.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/internal",
-  "version": "0.2.2-dev-4874362.0+4874362",
+  "version": "0.2.2-dev-5933241.0+5933241",
   "description": "Externally unsupported utilities internal to agoric-sdk",
   "type": "module",
   "main": "src/index.js",
@@ -20,7 +20,8 @@
     "lint:types": "tsc -p jsconfig.json"
   },
   "dependencies": {
-    "@endo/eventual-send": "^0.16.8",
+    "@agoric/zone": "0.1.1-dev-5933241.0+5933241",
+    "@endo/far": "^0.2.14",
     "@endo/marshal": "^0.8.1",
     "@endo/promise-kit": "^0.2.52",
     "jessie.js": "^0.3.2"
@@ -37,5 +38,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "4874362b8f9aa4f7c9f67ef7761bd78df126f267"
+  "gitHead": "5933241100b910022eca47f872451a82207d0dfd"
 }

package/src/callback.d.ts

@@ -0,0 +1,9 @@
+export function callSync<I extends (...args: unknown[]) => any>(callback: import("./types").SyncCallback<I>, ...args: Parameters<I>): ReturnType<I>;
+export function callE<I extends (...args: unknown[]) => any>(callback: import("./types").Callback<I>, ...args: Parameters<I>): Promise<Awaited<ReturnType<I>>>;
+export function makeSyncFunctionCallback<I extends (...args: unknown[]) => any, T extends (...args: [...B, ...Parameters<I>]) => ReturnType<I> = I, B extends unknown[] = []>(target: T, ...bound: B): import("./types").SyncCallback<I>;
+export function makeFunctionCallback<I extends (...args: unknown[]) => any, T extends import("@endo/far").ERef<(...args: [...B, ...Parameters<I>]) => ReturnType<I>> = import("@endo/far").ERef<I>, B extends unknown[] = []>(target: T, ...bound: B): import("./types").Callback<I>;
+export function makeSyncMethodCallback<I extends (...args: unknown[]) => any, P extends PropertyKey, T extends { [x in P]: (...args: [...B, ...Parameters<I>]) => ReturnType<I>; } = { [x_1 in P]: I; }, B extends unknown[] = []>(target: T, methodName: P, ...bound: B): import("./types").SyncCallback<I>;
+export function makeMethodCallback<I extends (...args: unknown[]) => any, P extends PropertyKey, T extends import("@endo/far").ERef<{ [x in P]: (...args: [...B, ...Parameters<I>]) => ReturnType<I>; }> = import("@endo/far").ERef<{ [x_1 in P]: I; }>, B extends unknown[] = []>(target: T, methodName: P, ...bound: B): import("./types").Callback<I>;
+export type Callback<I extends (...args: unknown[]) => any> = import('./types').Callback<I>;
+export type SyncCallback<I extends (...args: unknown[]) => any> = import('./types').SyncCallback<I>;
+//# sourceMappingURL=callback.d.ts.map

package/src/callback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callback.d.ts","sourceRoot":"","sources":["callback.js"],"names":[],"mappings":"AAqBO,6CALiB,OAAO,EAAE,KAAK,GAAG,sFAWxC;AAUM,0CALiB,OAAO,EAAE,KAAK,GAAG,oGAWxC;AAYM,6DAPiB,OAAO,EAAE,KAAK,GAAG,2JAWxC;AAeM,yDATiB,OAAO,EAAE,KAAK,GAAG,2MAaxC;AAiBM,2DAXiB,OAAO,EAAE,KAAK,GAAG,iOAexC;AAiBM,uDAXiB,OAAO,EAAE,KAAK,GAAG,iRAexC;yCApHuB,OAAO,EAAE,KAAK,GAAG,IAC5B,OAAO,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC;6CAIlB,OAAO,EAAE,KAAK,GAAG,IAC5B,OAAO,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC"}

package/src/callback.js

@@ -0,0 +1,122 @@
+// @ts-check
+import { E } from '@endo/far';
+
+/**
+ * @template {(...args: unknown[]) => any} I
+ * @typedef {import('./types').Callback<I>} Callback
+ */
+
+/**
+ * @template {(...args: unknown[]) => any} I
+ * @typedef {import('./types').SyncCallback<I>} SyncCallback
+ */
+
+/**
+ * Synchronously call a callback.
+ *
+ * @template {(...args: unknown[]) => any} I
+ * @param {SyncCallback<I>} callback
+ * @param {Parameters<I>} args
+ * @returns {ReturnType<I>}
+ */
+export const callSync = (callback, ...args) => {
+  const { target, method, bound } = callback;
+  if (method === undefined) {
+    return target(...bound, ...args);
+  }
+  return target[method](...bound, ...args);
+};
+
+/**
+ * Eventual send to a callback.
+ *
+ * @template {(...args: unknown[]) => any} I
+ * @param {Callback<I>} callback
+ * @param {Parameters<I>} args
+ * @returns {Promise<Awaited<ReturnType<I>>>}
+ */
+export const callE = (callback, ...args) => {
+  const { target, method, bound } = callback;
+  if (method === undefined) {
+    return E(target)(...bound, ...args);
+  }
+  return E(target)[method](...bound, ...args);
+};
+
+/**
+ * Create a callback from a near function.
+ *
+ * @template {(...args: unknown[]) => any} I
+ * @template {(...args: [...B, ...Parameters<I>]) => ReturnType<I>} [T=I]
+ * @template {unknown[]} [B=[]]
+ * @param {T} target
+ * @param {B} bound
+ * @returns {SyncCallback<I>}
+ */
+export const makeSyncFunctionCallback = (target, ...bound) => {
+  /** @type {unknown} */
+  const cb = harden({ target, bound });
+  return /** @type {SyncCallback<I>} */ (cb);
+};
+harden(makeSyncFunctionCallback);
+
+/**
+ * Create a callback from a potentially far function.
+ *
+ * @template {(...args: unknown[]) => any} I
+ * @template {import('@endo/far').ERef<
+ *   (...args: [...B, ...Parameters<I>]) => ReturnType<I>
+ * >} [T=import('@endo/far').ERef<I>]
+ * @template {unknown[]} [B=[]]
+ * @param {T} target
+ * @param {B} bound
+ * @returns {Callback<I>}
+ */
+export const makeFunctionCallback = (target, ...bound) => {
+  /** @type {unknown} */
+  const cb = harden({ target, bound });
+  return /** @type {Callback<I>} */ (cb);
+};
+harden(makeFunctionCallback);
+
+/**
+ * Create a callback from a near method.
+ *
+ * @template {(...args: unknown[]) => any} I
+ * @template {PropertyKey} P
+ * @template {{
+ *   [x in P]: (...args: [...B, ...Parameters<I>]) => ReturnType<I>
+ * }} [T={ [x in P]: I }]
+ * @template {unknown[]} [B=[]]
+ * @param {T} target
+ * @param {P} methodName
+ * @param {B} bound
+ * @returns {SyncCallback<I>}
+ */
+export const makeSyncMethodCallback = (target, methodName, ...bound) => {
+  /** @type {unknown} */
+  const cb = harden({ target, method: methodName, bound });
+  return /** @type {SyncCallback<I>} */ (cb);
+};
+harden(makeSyncMethodCallback);
+
+/**
+ * Create a callback from a potentially far method.
+ *
+ * @template {(...args: unknown[]) => any} I
+ * @template {PropertyKey} P
+ * @template {import('@endo/far').ERef<{
+ *   [x in P]: (...args: [...B, ...Parameters<I>]) => ReturnType<I>
+ * }>} [T=import('@endo/far').ERef<{ [x in P]: I }>]
+ * @template {unknown[]} [B=[]]
+ * @param {T} target
+ * @param {P} methodName
+ * @param {B} bound
+ * @returns {Callback<I>}
+ */
+export const makeMethodCallback = (target, methodName, ...bound) => {
+  /** @type {unknown} */
+  const cb = harden({ target, method: methodName, bound });
+  return /** @type {Callback<I>} */ (cb);
+};
+harden(makeMethodCallback);

package/src/lib-chainStorage.d.ts

@@ -1,31 +1,44 @@
 /**
- * Must match the switch in vstorage.go using `vstorageMessage` type
- *
- * @typedef { 'get' | 'getStoreKey' | 'has' | 'entries' | 'values' |'size' } StorageGetByPathMessageMethod
- * @typedef { 'set' | 'append' } StorageUpdateEntriesMessageMethod
- * @typedef {StorageGetByPathMessageMethod | StorageUpdateEntriesMessageMethod } StorageMessageMethod
- * @typedef { [path: string] } StorageGetByPathMessageArgs
- * @typedef { [path: string, value?: string | null] } StorageEntry
- * @typedef { StorageEntry[] } StorageUpdateEntriesMessageArgs
- * @typedef {{
- *   method: StorageGetByPathMessageMethod;
- *   args: StorageGetByPathMessageArgs;
- *  } | {
- *   method: StorageUpdateEntriesMessageMethod;
- *   args: StorageUpdateEntriesMessageArgs;
- * }} StorageMessage
- */
-/**
- * Create a root storage node for a given backing function and root path.
+ * Create a heap-based root storage node for a given backing function and root path.
  *
- * @param {(message: StorageMessage) => any} handleStorageMessage a function for sending a storageMessage object to the storage implementation (cf. golang/cosmos/x/vstorage/vstorage.go)
+ * @param {(message: StorageMessage) => any} handleStorageMessage a function for
+ * sending a storageMessage object to the storage implementation
+ * (cf. golang/cosmos/x/vstorage/vstorage.go)
  * @param {string} rootPath
  * @param {object} [rootOptions]
- * @param {boolean} [rootOptions.sequence] employ a wrapping structure that preserves each value set within a single block, and default child nodes to do the same
+ * @param {boolean} [rootOptions.sequence] employ a wrapping structure that
+ * preserves each value set within a single block, and default child nodes
+ * to do the same
  */
 export function makeChainStorageRoot(handleStorageMessage: (message: StorageMessage) => any, rootPath: string, rootOptions?: {
     sequence?: boolean | undefined;
-} | undefined): StorageNode;
+} | undefined): {
+    getPath(): string;
+    /**
+     * @deprecated use getPath
+     * @type {() => Promise<VStorageKey>}
+     */
+    getStoreKey(): Promise<VStorageKey>;
+    /** @type {(name: string, childNodeOptions?: {sequence?: boolean}) => StorageNode} */
+    makeChildNode(name: string, childNodeOptions?: {
+        sequence?: boolean | undefined;
+    } | undefined): StorageNode;
+    /** @type {(value: string) => Promise<void>} */
+    setValue(value: string): Promise<void>;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    getPath(): string;
+    /**
+     * @deprecated use getPath
+     * @type {() => Promise<VStorageKey>}
+     */
+    getStoreKey(): Promise<VStorageKey>;
+    /** @type {(name: string, childNodeOptions?: {sequence?: boolean}) => StorageNode} */
+    makeChildNode(name: string, childNodeOptions?: {
+        sequence?: boolean | undefined;
+    } | undefined): StorageNode;
+    /** @type {(value: string) => Promise<void>} */
+    setValue(value: string): Promise<void>;
+}>;
 /**
  * Convenience function for returning a storage node at or under its input,
  * falling back to an inert object with the correct interface (but incomplete
@@ -38,41 +51,36 @@ export function makeChainStorageRoot(handleStorageMessage: (message: StorageMess
 export function makeStorageNodeChild(storageNodeRef: import('@endo/far').ERef<StorageNode | null>, childName: string): Promise<StorageNode>;
 /** @type {(name: string) => void} */
 export const assertPathSegment: (name: string) => void;
+export function prepareChainStorageNode(zone: import('@agoric/zone').Zone): (args_0: import("./types.js").Callback<(message: StorageMessage) => any>, args_1: string, args_2?: {
+    sequence?: boolean | undefined;
+} | undefined) => {
+    getPath(): string;
+    /**
+     * @deprecated use getPath
+     * @type {() => Promise<VStorageKey>}
+     */
+    getStoreKey(): Promise<VStorageKey>;
+    /** @type {(name: string, childNodeOptions?: {sequence?: boolean}) => StorageNode} */
+    makeChildNode(name: string, childNodeOptions?: {
+        sequence?: boolean | undefined;
+    } | undefined): StorageNode;
+    /** @type {(value: string) => Promise<void>} */
+    setValue(value: string): Promise<void>;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    getPath(): string;
+    /**
+     * @deprecated use getPath
+     * @type {() => Promise<VStorageKey>}
+     */
+    getStoreKey(): Promise<VStorageKey>;
+    /** @type {(name: string, childNodeOptions?: {sequence?: boolean}) => StorageNode} */
+    makeChildNode(name: string, childNodeOptions?: {
+        sequence?: boolean | undefined;
+    } | undefined): StorageNode;
+    /** @type {(value: string) => Promise<void>} */
+    setValue(value: string): Promise<void>;
+}>;
 export function makeSerializeToStorage(storageNode: import('@endo/far').ERef<StorageNode>, marshaller: import('@endo/far').ERef<Marshaller>): (value: unknown) => Promise<void>;
-/**
- * Must match the switch in vstorage.go using `vstorageMessage` type
- */
-export type StorageGetByPathMessageMethod = 'get' | 'getStoreKey' | 'has' | 'entries' | 'values' | 'size';
-/**
- * Must match the switch in vstorage.go using `vstorageMessage` type
- */
-export type StorageUpdateEntriesMessageMethod = 'set' | 'append';
-/**
- * Must match the switch in vstorage.go using `vstorageMessage` type
- */
-export type StorageMessageMethod = StorageGetByPathMessageMethod | StorageUpdateEntriesMessageMethod;
-/**
- * Must match the switch in vstorage.go using `vstorageMessage` type
- */
-export type StorageGetByPathMessageArgs = [path: string];
-/**
- * Must match the switch in vstorage.go using `vstorageMessage` type
- */
-export type StorageEntry = [path: string, value?: string | null];
-/**
- * Must match the switch in vstorage.go using `vstorageMessage` type
- */
-export type StorageUpdateEntriesMessageArgs = [path: string, value?: string | null | undefined][];
-/**
- * Must match the switch in vstorage.go using `vstorageMessage` type
- */
-export type StorageMessage = {
-    method: StorageGetByPathMessageMethod;
-    args: [path: string];
-} | {
-    method: StorageUpdateEntriesMessageMethod;
-    args: StorageUpdateEntriesMessageArgs;
-};
 export type Marshaller = ReturnType<typeof import('@endo/marshal').makeMarshal>;
 export type Unserializer = Pick<Marshaller, 'unserialize'>;
 /**
@@ -124,4 +132,38 @@ export type StoredFacet = {
      */
     getUnserializer: () => Unserializer;
 };
+/**
+ * Must match the switch in vstorage.go using `vstorageMessage` type
+ */
+export type StorageGetByPathMessageMethod = 'get' | 'getStoreKey' | 'has' | 'entries' | 'values' | 'size';
+/**
+ * Must match the switch in vstorage.go using `vstorageMessage` type
+ */
+export type StorageUpdateEntriesMessageMethod = 'set' | 'append';
+/**
+ * Must match the switch in vstorage.go using `vstorageMessage` type
+ */
+export type StorageMessageMethod = StorageGetByPathMessageMethod | StorageUpdateEntriesMessageMethod;
+/**
+ * Must match the switch in vstorage.go using `vstorageMessage` type
+ */
+export type StorageGetByPathMessageArgs = [path: string];
+/**
+ * Must match the switch in vstorage.go using `vstorageMessage` type
+ */
+export type StorageEntry = [path: string, value?: string | null];
+/**
+ * Must match the switch in vstorage.go using `vstorageMessage` type
+ */
+export type StorageUpdateEntriesMessageArgs = [path: string, value?: string | null | undefined][];
+/**
+ * Must match the switch in vstorage.go using `vstorageMessage` type
+ */
+export type StorageMessage = {
+    method: StorageGetByPathMessageMethod;
+    args: [path: string];
+} | {
+    method: StorageUpdateEntriesMessageMethod;
+    args: StorageUpdateEntriesMessageArgs;
+};
 //# 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":"AAwDA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;GAOG;AACH,qEALqB,cAAc,KAAK,GAAG,YAChC,MAAM;;4BAoEhB;AAUD;;;;;;;;GAQG;AACH,qDAJW,OAAO,WAAW,EAAE,IAAI,CAAC,WAAW,QAAE,aACtC,MAAM,GACJ,QAAQ,WAAW,CAAC,CAMhC;AAxHD,qCAAqC;AACrC,uCADkB,MAAM,KAAK,IAAI,CAI/B;AA8HK,oDAJI,OAAO,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,cACrC,OAAO,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,WAC1B,OAAO,KAAK,QAAQ,IAAI,CAAC,CAQ7C;;;;4CA9Ha,KAAK,GAAG,aAAa,GAAG,KAAK,GAAG,SAAS,GAAG,QAAQ,GAAE,MAAM;;;;gDAC5D,KAAK,GAAG,QAAQ;;;;mCACjB,6BAA6B,GAAG,iCAAiC;;;;0CAChE,CAAC,IAAI,EAAE,MAAM,CAAC;;;;2BACd,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;;;;8CACrC,mDAAc;;;;6BACf;IACZ,MAAU,EAAE,6BAA6B,CAAC;IAC1C,IAAQ,iBAA8B;CAClC,GAAG;IACP,MAAU,EAAE,iCAAiC,CAAC;IAC9C,IAAQ,kCAAkC;CACvC;yBAhEU,WAAW,cAAc,eAAe,EAAE,WAAW,CAAC;2BACtD,KAAK,UAAU,EAAE,aAAa,CAAC;;;;;eAM/B,MAAM;iBACN,MAAM;qBACN,MAAM;;;;;;;;;;;;;;;;qBAcC,MAAM,KAAK,QAAQ,IAAI,CAAC;;;;aAC/B,MAAM,MAAM;;;;iBACZ,MAAM,QAAQ,WAAW,CAAC;6BAChB,MAAM,YAAY;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAC,KAAK,WAAW;;;;;;aAKhE,MAAM,QAAQ,MAAM,CAAC;;;;iBACrB,WAAW,CAAC,aAAa,CAAC;;;;qBAC1B,MAAM,YAAY"}
+{"version":3,"file":"lib-chainStorage.d.ts","sourceRoot":"","sources":["lib-chainStorage.js"],"names":[],"mappings":"AA4KA;;;;;;;;;;;GAWG;AACH,qEATqB,cAAc,KAAK,GAAG,YAGhC,MAAM;;;;IA1DX;;;OAGG;mBADa,QAAQ,WAAW,CAAC;IASpC,qFAAqF;wBAAnE,MAAM;;oBAA8C,WAAW;IAWjF,+CAA+C;oBAA5B,MAAM,GAAK,QAAQ,IAAI,CAAC;;;IAtB3C;;;OAGG;mBADa,QAAQ,WAAW,CAAC;IASpC,qFAAqF;wBAAnE,MAAM;;oBAA8C,WAAW;IAWjF,+CAA+C;oBAA5B,MAAM,GAAK,QAAQ,IAAI,CAAC;GAoDhD;AAUD;;;;;;;;GAQG;AACH,qDAJW,OAAO,WAAW,EAAE,IAAI,CAAC,WAAW,QAAE,aACtC,MAAM,GACJ,QAAQ,WAAW,CAAC,CAMhC;AA9JD,qCAAqC;AACrC,uCADkB,MAAM,KAAK,IAAI,CAI/B;AAwBK,8CAFI,OAAO,cAAc,EAAE,IAAI,oDAqBiB,cAAc,KAAK,GAAG;;;;IAcvE;;;OAGG;mBADa,QAAQ,WAAW,CAAC;IASpC,qFAAqF;wBAAnE,MAAM;;oBAA8C,WAAW;IAWjF,+CAA+C;oBAA5B,MAAM,GAAK,QAAQ,IAAI,CAAC;;;IAtB3C;;;OAGG;mBADa,QAAQ,WAAW,CAAC;IASpC,qFAAqF;wBAAnE,MAAM;;oBAA8C,WAAW;IAWjF,+CAA+C;oBAA5B,MAAM,GAAK,QAAQ,IAAI,CAAC;GA0BhD;AA2DM,oDAJI,OAAO,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,cACrC,OAAO,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,WAC1B,OAAO,KAAK,QAAQ,IAAI,CAAC,CAQ7C;yBAjOa,WAAW,cAAc,eAAe,EAAE,WAAW,CAAC;2BACtD,KAAK,UAAU,EAAE,aAAa,CAAC;;;;;eAM/B,MAAM;iBACN,MAAM;qBACN,MAAM;;;;;;;;;;;;;;;;qBAcC,MAAM,KAAK,QAAQ,IAAI,CAAC;;;;aAC/B,MAAM,MAAM;;;;iBACZ,MAAM,QAAQ,WAAW,CAAC;6BAChB,MAAM,YAAY;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAC,KAAK,WAAW;;;;;;aAchE,MAAM,QAAQ,MAAM,CAAC;;;;iBACrB,WAAW,CAAC,aAAa,CAAC;;;;qBAC1B,MAAM,YAAY;;;;;4CAmBlB,KAAK,GAAG,aAAa,GAAG,KAAK,GAAG,SAAS,GAAG,QAAQ,GAAE,MAAM;;;;gDAC5D,KAAK,GAAG,QAAQ;;;;mCACjB,6BAA6B,GAAG,iCAAiC;;;;0CAChE,CAAC,IAAI,EAAE,MAAM,CAAC;;;;2BACd,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;;;;8CACrC,mDAAc;;;;6BACf;IACZ,MAAU,EAAE,6BAA6B,CAAC;IAC1C,IAAQ,iBAA8B;CAClC,GAAG;IACP,MAAU,EAAE,iCAAiC,CAAC;IAC9C,IAAQ,kCAAkC;CACvC"}

package/src/lib-chainStorage.js

@@ -1,7 +1,8 @@
 // @ts-check
 
-import { E } from '@endo/eventual-send';
-import { Far } from '@endo/marshal';
+import { E } from '@endo/far';
+import { M, heapZone } from '@agoric/zone';
+import * as cb from './callback.js';
 
 const { Fail } = assert;
 
@@ -34,6 +35,15 @@ const { Fail } = assert;
  * @property {(subPath: string, options?: {sequence?: boolean}) => StorageNode} makeChildNode
  */
 
+const ChainStorageNodeI = M.interface('StorageNode', {
+  setValue: M.callWhen(M.string()).returns(),
+  getPath: M.call().returns(M.string()),
+  getStoreKey: M.callWhen().returns(M.record()),
+  makeChildNode: M.call(M.string())
+    .optional(M.splitRecord({}, { sequence: M.boolean() }, {}))
+    .returns(M.remotable('StorageNode')),
+});
+
 /**
  * @typedef {object} StoredFacet
  * @property {() => Promise<string>} getPath the chain storage path at which the node was constructed
@@ -73,51 +83,66 @@ harden(assertPathSegment);
  */
 
 /**
- * Create a root storage node for a given backing function and root path.
- *
- * @param {(message: StorageMessage) => any} handleStorageMessage a function for sending a storageMessage object to the storage implementation (cf. golang/cosmos/x/vstorage/vstorage.go)
- * @param {string} rootPath
- * @param {object} [rootOptions]
- * @param {boolean} [rootOptions.sequence] employ a wrapping structure that preserves each value set within a single block, and default child nodes to do the same
+ * @param {import('@agoric/zone').Zone} zone
  */
-export function makeChainStorageRoot(
-  handleStorageMessage,
-  rootPath,
-  rootOptions = {},
-) {
-  assert.typeof(rootPath, 'string');
-
+export const prepareChainStorageNode = zone => {
   /**
+   * Create a storage node for a given backing storage interface and path.
+   *
+   * @param {import('./callback').Callback<(message: StorageMessage) => any>} messenger a callback
+   * for sending a storageMessage object to the storage implementation
+   * (cf. golang/cosmos/x/vstorage/vstorage.go)
    * @param {string} path
    * @param {object} [options]
-   * @param {boolean} [options.sequence]
+   * @param {boolean} [options.sequence] set values with `append` messages rather than `set` messages
+   * so the backing implementation employs a wrapping structure that
+   * preserves each value set within a single block.
+   * Child nodes default to inheriting this option from their parent.
    * @returns {StorageNode}
    */
-  function makeChainStorageNode(path, options = {}) {
-    const { sequence = false } = options;
-    const node = {
+  const makeChainStorageNode = zone.exoClass(
+    'ChainStorageNode',
+    ChainStorageNodeI,
+    /**
+     * @param {import('./callback').Callback<(message: StorageMessage) => any>} messenger
+     * @param {string} path
+     * @param {object} [options]
+     * @param {boolean} [options.sequence]
+     */
+    (messenger, path, { sequence = false } = {}) => {
+      assert.typeof(path, 'string');
+      assert.typeof(sequence, 'boolean');
+      return harden({ path, messenger, sequence });
+    },
+    {
       getPath() {
-        return path;
+        return this.state.path;
       },
       /**
        * @deprecated use getPath
        * @type {() => Promise<VStorageKey>}
        */
       async getStoreKey() {
-        return handleStorageMessage({
+        const { path, messenger } = this.state;
+        return cb.callE(messenger, {
           method: 'getStoreKey',
           args: [path],
         });
       },
       /** @type {(name: string, childNodeOptions?: {sequence?: boolean}) => StorageNode} */
       makeChildNode(name, childNodeOptions = {}) {
-        assert.typeof(name, 'string');
+        const { sequence, path, messenger } = this.state;
         assertPathSegment(name);
         const mergedOptions = { sequence, ...childNodeOptions };
-        return makeChainStorageNode(`${path}.${name}`, mergedOptions);
+        return makeChainStorageNode(
+          messenger,
+          `${path}.${name}`,
+          mergedOptions,
+        );
       },
       /** @type {(value: string) => Promise<void>} */
       async setValue(value) {
+        const { sequence, path, messenger } = this.state;
         assert.typeof(value, 'string');
         /** @type {StorageEntry} */
         let entry;
@@ -126,7 +151,7 @@ export function makeChainStorageRoot(
         } else {
           entry = [path, value];
         }
-        await handleStorageMessage({
+        await cb.callE(messenger, {
           method: sequence ? 'append' : 'set',
           args: [entry],
         });
@@ -138,11 +163,34 @@ export function makeChainStorageRoot(
       // * recursive delete
       // * batch operations
       // * local buffering (with end-of-block commit)
-    };
-    return Far('chainStorageNode', node);
-  }
+    },
+  );
+  return makeChainStorageNode;
+};
+
+const makeHeapChainStorageNode = prepareChainStorageNode(heapZone);
+
+/**
+ * Create a heap-based root storage node for a given backing function and root path.
+ *
+ * @param {(message: StorageMessage) => any} handleStorageMessage a function for
+ * sending a storageMessage object to the storage implementation
+ * (cf. golang/cosmos/x/vstorage/vstorage.go)
+ * @param {string} rootPath
+ * @param {object} [rootOptions]
+ * @param {boolean} [rootOptions.sequence] employ a wrapping structure that
+ * preserves each value set within a single block, and default child nodes
+ * to do the same
+ */
+export function makeChainStorageRoot(
+  handleStorageMessage,
+  rootPath,
+  rootOptions = {},
+) {
+  const messenger = cb.makeFunctionCallback(handleStorageMessage);
 
-  const rootNode = makeChainStorageNode(rootPath, rootOptions);
+  // Use the heapZone directly.
+  const rootNode = makeHeapChainStorageNode(messenger, rootPath, rootOptions);
   return rootNode;
 }
 

package/src/method-tools.d.ts

@@ -1,4 +1,3 @@
-export function getMethodNames(val: any): (string | symbol)[];
-export function bindAllMethods(obj: Remotable): Remotable;
-export type Remotable = import('@endo/marshal/src/types').Remotable;
+export function getMethodNames<K extends PropertyKey>(val: Record<K, any>): K[];
+export function bindAllMethods<T extends Record<PropertyKey, any>>(obj: T): T;
 //# sourceMappingURL=method-tools.d.ts.map

package/src/method-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"method-tools.d.ts","sourceRoot":"","sources":["method-tools.js"],"names":[],"mappings":"AA0CO,oCAHI,GAAG,GACD,CAAC,MAAM,GAAC,MAAM,CAAC,EAAE,CAqB7B;AA+BM,oCAHI,SAAS,GACP,SAAS,CAiBnB;wBAhGW,OAAO,yBAAyB,EAAE,SAAS"}
+{"version":3,"file":"method-tools.d.ts","sourceRoot":"","sources":["method-tools.js"],"names":[],"mappings":"AAyCO,gFAoBN;AAgCM,8EAeJ"}

package/src/method-tools.js

@@ -9,8 +9,6 @@ const { getPrototypeOf, create, fromEntries, getOwnPropertyDescriptors } =
   Object;
 const { ownKeys, apply } = Reflect;
 
-/** @typedef {import('@endo/marshal/src/types').Remotable} Remotable */
-
 /**
  * Prioritize symbols as earlier than strings.
  *
@@ -37,8 +35,9 @@ const compareStringified = (a, b) => {
 /**
  * TODO Consolidate with the `getMethodNames` in `@endo/eventual-send`
  *
- * @param {any} val
- * @returns {(string|symbol)[]}
+ * @template {PropertyKey} K
+ * @param {Record<K, any>} val
+ * @returns {K[]}
  */
 export const getMethodNames = val => {
   let layer = val;
@@ -46,7 +45,8 @@ export const getMethodNames = val => {
   while (layer !== null && layer !== Object.prototype) {
     // be tolerant of non-objects
     const descs = getOwnPropertyDescriptors(layer);
-    for (const name of ownKeys(descs)) {
+    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') {
@@ -87,8 +87,9 @@ harden(getMethodNames);
  * object has bound own methods overridding all the methods it would have
  * inherited from `obj`.
  *
- * @param {Remotable} obj
- * @returns {Remotable}
+ * @template {Record<PropertyKey, any>} T
+ * @param {T} obj
+ * @returns {T}
  */
 export const bindAllMethods = obj =>
   harden(

package/src/storage-test-utils.d.ts

@@ -1,5 +1,19 @@
 export function makeFakeStorageKit(rootPath: string, rootOptions?: object | undefined): {
-    rootNode: import("./lib-chainStorage.js").StorageNode;
+    rootNode: {
+        getPath(): string;
+        getStoreKey(): Promise<import("./lib-chainStorage.js").VStorageKey>;
+        makeChildNode(name: string, childNodeOptions?: {
+            sequence?: boolean | undefined;
+        } | undefined): import("./lib-chainStorage.js").StorageNode;
+        setValue(value: string): Promise<void>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        getPath(): string;
+        getStoreKey(): Promise<import("./lib-chainStorage.js").VStorageKey>;
+        makeChildNode(name: string, childNodeOptions?: {
+            sequence?: boolean | undefined;
+        } | undefined): import("./lib-chainStorage.js").StorageNode;
+        setValue(value: string): Promise<void>;
+    }>;
     data: Map<string, any>;
     messages: import("./lib-chainStorage.js").StorageMessage[];
     toStorage: (message: import('../src/lib-chainStorage.js').StorageMessage) => Promise<number | {
@@ -18,21 +32,12 @@ export function makeMockChainStorageRoot(): {
      * @returns {unknown}
      */
     getBody: (path: string, marshaller?: import('./lib-chainStorage.js').Marshaller) => unknown;
-    /**
-     * publishes some data
-     */
-    setValue: (data: string) => Promise<void>;
-    /**
-     * the chain storage path at which the node was constructed
-     */
-    getPath: () => string;
-    /**
-     * DEPRECATED use getPath
-     */
-    getStoreKey: () => Promise<import("./lib-chainStorage.js").VStorageKey>;
-    makeChildNode: (subPath: string, options?: {
+    getPath(): string;
+    getStoreKey(): Promise<import("./lib-chainStorage.js").VStorageKey>;
+    makeChildNode(name: string, childNodeOptions?: {
         sequence?: boolean | undefined;
-    } | undefined) => import("./lib-chainStorage.js").StorageNode;
+    } | undefined): import("./lib-chainStorage.js").StorageNode;
+    setValue(value: string): Promise<void>;
 } & import("@endo/eventual-send").RemotableBrand<{}, {
     /**
      *  Defaults to deserializing pass-by-presence objects into { iface } representations.
@@ -44,21 +49,12 @@ export function makeMockChainStorageRoot(): {
      * @returns {unknown}
      */
     getBody: (path: string, marshaller?: import('./lib-chainStorage.js').Marshaller) => unknown;
-    /**
-     * publishes some data
-     */
-    setValue: (data: string) => Promise<void>;
-    /**
-     * the chain storage path at which the node was constructed
-     */
-    getPath: () => string;
-    /**
-     * DEPRECATED use getPath
-     */
-    getStoreKey: () => Promise<import("./lib-chainStorage.js").VStorageKey>;
-    makeChildNode: (subPath: string, options?: {
+    getPath(): string;
+    getStoreKey(): Promise<import("./lib-chainStorage.js").VStorageKey>;
+    makeChildNode(name: string, childNodeOptions?: {
         sequence?: boolean | undefined;
-    } | undefined) => import("./lib-chainStorage.js").StorageNode;
+    } | undefined): import("./lib-chainStorage.js").StorageNode;
+    setValue(value: string): Promise<void>;
 }>;
 export type FakeStorageKit = ReturnType<typeof makeFakeStorageKit>;
 export type MockChainStorageRoot = ReturnType<typeof makeMockChainStorageRoot>;

package/src/storage-test-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage-test-utils.d.ts","sourceRoot":"","sources":["storage-test-utils.js"],"names":[],"mappings":"AAaO,6CAHI,MAAM;;;;yBAQH,OAAO,4BAA4B,EAAE,cAAc;;;;EAkDhE;AAIM;IASH;;;;;;;;OAQG;oBAHQ,MAAM,eACN,OAAO,uBAAuB,EAAE,UAAU,KACxC,OAAO;;;;;;;;;;;;;;;;;IAPpB;;;;;;;;OAQG;oBAHQ,MAAM,eACN,OAAO,uBAAuB,EAAE,UAAU,KACxC,OAAO;;;;;;;;;;;;;;;;GAcvB;6BAhCa,WAAY,yBAAyB,CAAC;mCAiCtC,WAAW,+BAA+B,CAAC"}
+{"version":3,"file":"storage-test-utils.d.ts","sourceRoot":"","sources":["storage-test-utils.js"],"names":[],"mappings":"AAeO,6CAHI,MAAM;;;;;;;;;;;;;;;;;;yBAQH,OAAO,4BAA4B,EAAE,cAAc;;;;EAkDhE;AAIM;IASH;;;;;;;;OAQG;oBAHQ,MAAM,eACN,OAAO,uBAAuB,EAAE,UAAU,KACxC,OAAO;;;;;;;;IAPpB;;;;;;;;OAQG;oBAHQ,MAAM,eACN,OAAO,uBAAuB,EAAE,UAAU,KACxC,OAAO;;;;;;;GAcvB;6BAhCa,WAAY,yBAAyB,CAAC;mCAiCtC,WAAW,+BAA+B,CAAC"}

package/src/storage-test-utils.js

@@ -1,6 +1,8 @@
 // @ts-check
-import { Far, makeMarshal } from '@endo/marshal';
+import { Far } from '@endo/far';
+import { makeMarshal } from '@endo/marshal';
 import { makeChainStorageRoot } from './lib-chainStorage.js';
+import { bindAllMethods } from './method-tools.js';
 
 const { Fail, quote: q } = assert;
 
@@ -78,7 +80,7 @@ export const makeMockChainStorageRoot = () => {
   }));
 
   return Far('mockChainStorage', {
-    ...rootNode,
+    ...bindAllMethods(rootNode),
     /**
      *  Defaults to deserializing pass-by-presence objects into { iface } representations.
      * Note that this is **not** a null transformation; capdata `@qclass` and `index` properties

package/src/types.d.ts

@@ -0,0 +1,16 @@
+/* eslint-disable max-classes-per-file */
+export declare class Callback<I extends (...args: unknown[]) => any> {
+  private iface: I;
+
+  public target: any;
+
+  public method?: PropertyKey;
+
+  public bound: unknown[];
+}
+
+export declare class SyncCallback<
+  I extends (...args: unknown[]) => any,
+> extends Callback<I> {
+  private syncIface: I;
+}

package/src/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.js"],"names":[],"mappings":"AAYA,kCAAoC;AAa7B,0EAcN;AA0CM,gJAIN;AAQM,0CAHI,MAAM,MAAM,GAAG,MAAM,CAAC,cACtB,MAAM,MAAM,GAAG,MAAM,CAAC,uBAKhC;AASM,uCALI,KAAK,SACL,MAAM,GAAC,MAAM,oDAEX,KAAK,CAYjB;AAUM,uHAsBN;AAGD;;;;;GAKG;AAEH;;GAEG;AAEH;;;GAGG;AAEH;;;GAGG;AAEH;;;;;;;GAOG;AACH,qGAGE;AAUK,wDAHI,cAAc,YAAY,EAAE,WAAW,CAAC,GAAG;;cACmB,MAAM;GAW9E;AAMM,2CAHI,KAAK,EAAE,uCAcjB;AAOM,4FAeN;AAED;;;;;GAKG,CAAC,mFAFoB,OAAO,KAAK,QAAQ,IAAI,CAAC,gBAY7C;AAiBG,0GAUN;AAQD,+CAAoD;AAU7C,0EAUH;AAUG,0EAaH;AAEJ,oDAAoD;AACpD,uDAAqE;AAErE,2GAA2G;AAC3G,+GAIE;;;;sBA3UwB,OAAO,qBAAqB,EAAE,IAAI,CAAC,CAAC,CAAC;;;;;;iCAgJxC,GAAG,EAAE,KAAK,GAAG;;+BAUvB,CAAC,SAAS,YAAY,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,SAAS,oBAAoB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.js"],"names":[],"mappings":"AAYA,kCAAoC;AAa7B,0EAcN;AA0CM,gJAIN;AAQM,0CAHI,MAAM,MAAM,GAAG,MAAM,CAAC,cACtB,MAAM,MAAM,GAAG,MAAM,CAAC,uBAKhC;AASM,uCALI,KAAK,SACL,MAAM,GAAC,MAAM,oDAEX,KAAK,CAYjB;AAUM,uHAyBN;AAGD;;;;;GAKG;AAEH;;GAEG;AAEH;;;GAGG;AAEH;;;GAGG;AAEH;;;;;;;GAOG;AACH,qGAGE;AAUK,wDAHI,cAAc,YAAY,EAAE,WAAW,CAAC,GAAG;;cACmB,MAAM;GAW9E;AAMM,2CAHI,KAAK,EAAE,uCAcjB;AAOM,4FAeN;AAED;;;;;GAKG,CAAC,mFAFoB,OAAO,KAAK,QAAQ,IAAI,CAAC,gBAY7C;AAiBG,0GAUN;AAQD,+CAAoD;AAU7C,0EAUH;AAUG,0EAaH;AAEJ,oDAAoD;AACpD,uDAAqE;AAErE,2GAA2G;AAC3G,+GAIE;;;;sBA9UwB,OAAO,qBAAqB,EAAE,IAAI,CAAC,CAAC,CAAC;;;;;;iCAmJxC,GAAG,EAAE,KAAK,GAAG;;+BAUvB,CAAC,SAAS,YAAY,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,SAAS,oBAAoB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC"}

package/src/utils.js

@@ -1,6 +1,6 @@
 // @ts-check
 // @jessie-check
-import { E } from '@endo/eventual-send';
+import { E } from '@endo/far';
 import { deeplyFulfilled, isObject } from '@endo/marshal';
 import { isPromise } from '@endo/promise-kit';
 import { asyncGenerate, makeSet } from 'jessie.js';
@@ -134,14 +134,17 @@ export const applyLabelingError = (func, args, label = undefined) => {
     throwLabeled(err, label);
   }
   if (isPromise(result)) {
-    // @ts-expect-error If result is a rejected promise, this will
-    // return a promise with a different rejection reason. But this
-    // confuses TypeScript because it types that case as `Promise<never>`
-    // which is cool for a promise that will never fulfll.
-    // But TypeScript doesn't understand that this will only happen
-    // when `result` was a rejected promise. In only this case `R`
-    // should already allow `Promise<never>` as a subtype.
-    return E.when(result, undefined, reason => throwLabeled(reason, label));
+    // If result is a rejected promise, this will return a promise with a
+    // different rejection reason. But this confuses TypeScript because it types
+    // that case as `Promise<never>` which is cool for a promise that will never
+    // fulfill.  But TypeScript doesn't understand that this will only happen
+    // when `result` was a rejected promise. In only this case `R` should
+    // already allow `Promise<never>` as a subtype.
+    /** @type {unknown} */
+    const relabeled = E.when(result, undefined, reason =>
+      throwLabeled(reason, label),
+    );
+    return /** @type {R} */ (relabeled);
   } else {
     return result;
   }