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

package/CHANGELOG.md

@@ -3,6 +3,58 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.3.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/internal@0.2.1...@agoric/internal@0.3.0) (2023-05-19)
+
+
+### ⚠ BREAKING CHANGES
+
+* emit smallcaps-format data in all marshallers
+
+### Features
+
+* Add SwingSet configuration to purge vstorage within (re-)bootstrap ([f248e91](https://github.com/Agoric/agoric-sdk/commit/f248e9116512374fb95f789b26e27b66cd5c34ca)), closes [#7681](https://github.com/Agoric/agoric-sdk/issues/7681)
+* **auction:** add an auctioneer to manage vault liquidation ([#7000](https://github.com/Agoric/agoric-sdk/issues/7000)) ([398b70f](https://github.com/Agoric/agoric-sdk/commit/398b70f7e028f957afc1582f0ee31eb2574c94d0)), closes [#6992](https://github.com/Agoric/agoric-sdk/issues/6992) [#7047](https://github.com/Agoric/agoric-sdk/issues/7047) [#7074](https://github.com/Agoric/agoric-sdk/issues/7074)
+* **casting:** handle noData value encoding ([530bc41](https://github.com/Agoric/agoric-sdk/commit/530bc41854cc7f5e5749e97e87fabc6163a17864))
+* **cosmic-swingset:** add after-commit action ([970a53f](https://github.com/Agoric/agoric-sdk/commit/970a53f827ded21b27525f6b0042bbc124c62d48))
+* **internal:** makeFakeStorageKit supports "get" and "entries" ([6a69aab](https://github.com/Agoric/agoric-sdk/commit/6a69aab5cb54faae5af631bbc2281e4fc4ede8e0))
+* **internal:** new `prepareAttenuator` leveraging callbacks ([55599df](https://github.com/Agoric/agoric-sdk/commit/55599dfe7ec43a27387ca64e8bae57be13a38115))
+* emit smallcaps-format data in all marshallers ([1753df8](https://github.com/Agoric/agoric-sdk/commit/1753df83465785b5ee71b250770c9b012d750ffc)), closes [#6822](https://github.com/Agoric/agoric-sdk/issues/6822)
+* **core:** HighPrioritySendersManager ([7b382e4](https://github.com/Agoric/agoric-sdk/commit/7b382e49a1521d367c5b8db18fa7efa2b77ef7e3))
+* **cosmic-swingset:** basic snapshot wiring ([b1072d8](https://github.com/Agoric/agoric-sdk/commit/b1072d8b1ddabbb5f2835eb503c945fed3b6b080))
+* **cosmic-swingset:** export swingStore kvData to vstorage ([be68431](https://github.com/Agoric/agoric-sdk/commit/be684315dc68ecf0cb603a8eb38ddd5418e996a6))
+* **cosmic-swingset:** process highPriorityQueue actions ([182a96e](https://github.com/Agoric/agoric-sdk/commit/182a96e169c8cac7f31fbce014783fd6db72b64c))
+* **cosmic-swingset:** remove unnecessary explicit activityhash ([5dcc44d](https://github.com/Agoric/agoric-sdk/commit/5dcc44d31be0c8a95a5749d768791fa35b72dbd3))
+* **internal:** add BufferLineTransform ([6e7db7a](https://github.com/Agoric/agoric-sdk/commit/6e7db7af7d93500caf71d817afbb358d33ef01f6))
+* **internal:** add sync tee util ([#7560](https://github.com/Agoric/agoric-sdk/issues/7560)) ([0f800a6](https://github.com/Agoric/agoric-sdk/commit/0f800a622b81c61101d96b0ad620ab3065f4b146))
+* **internal:** build `chainStorage` from `zone` ([74c62da](https://github.com/Agoric/agoric-sdk/commit/74c62dae7964b488bfdf7c7ee8a9bd930074cea8))
+* **internal:** iterable produces values and can be async ([cf4110f](https://github.com/Agoric/agoric-sdk/commit/cf4110f59c228e42e09254b271209a66b9faf3e0))
+* **internal:** new `callback` module for durable classless callbacks ([b94d600](https://github.com/Agoric/agoric-sdk/commit/b94d60052e1043fd6fb1ce39530a6072e38ef0d9))
+* **internal:** shutdown informs of interrupt signal ([2ce1e89](https://github.com/Agoric/agoric-sdk/commit/2ce1e892eb381a28c31805f48ba65511896ef406))
+* assertAllDefined ([d4d6cbd](https://github.com/Agoric/agoric-sdk/commit/d4d6cbd798eee051a8a699c85cc620c6a8298258))
+* board-utils ([4f80ad3](https://github.com/Agoric/agoric-sdk/commit/4f80ad3cac3e47a89834f7f98330a47141b6e235))
+* type assertion for assertAllDefined ([afa7b5b](https://github.com/Agoric/agoric-sdk/commit/afa7b5bfaf4558a38bdba2c44bf91691f6db26b8))
+* **store:** M.splitArray and M.splitRecord ([#6597](https://github.com/Agoric/agoric-sdk/issues/6597)) ([e7427e3](https://github.com/Agoric/agoric-sdk/commit/e7427e386bcbfbe99312b41342b1fa2e722c57c7))
+* **vats:** harmonise core/boot.js and boot-psm.js ([4f6635e](https://github.com/Agoric/agoric-sdk/commit/4f6635e550b926d3ca43d9075f26fef3b810817d))
+
+
+### Bug Fixes
+
+* **internal:** add typing to makeWithQueue ([5b1539b](https://github.com/Agoric/agoric-sdk/commit/5b1539bfc61ea4f937e2f85cbe93c7bccfc84a40))
+* **internal:** Make makeFakeStorageKit value auto-wrapping depend upon `sequence: true` ([2751e76](https://github.com/Agoric/agoric-sdk/commit/2751e7626e0ca617cdb2b1d92e5d4d9315b5674a))
+* **internal:** more callback typing ([e78e14d](https://github.com/Agoric/agoric-sdk/commit/e78e14d60a78d2e5f9fb9a899053bf778bb51360))
+* **internal:** properly inherit from `chainStorageNode` ([134a977](https://github.com/Agoric/agoric-sdk/commit/134a977f7bc4a2fc6eff3868d4d415c8c9714b4b))
+* **internal:** Restore support for passable-symbol method keys ([54271af](https://github.com/Agoric/agoric-sdk/commit/54271af10adb144fe6d562193afa473d74425854))
+* **internal:** shutdown beforeExit avoids forced exit ([34c9f44](https://github.com/Agoric/agoric-sdk/commit/34c9f442f124cd7181b538cf8754c6180c863b32))
+* **internal:** Validate Callback targets ([8880ada](https://github.com/Agoric/agoric-sdk/commit/8880ada791d70dd487770e8a0fa4b6b725aa8769))
+* **notifier:** Add a makeDurablePublishKit "onAdvance" option ([4c62b52](https://github.com/Agoric/agoric-sdk/commit/4c62b52b94cbc9ccb3c7388f5e94589809e6d7fd)), closes [#7303](https://github.com/Agoric/agoric-sdk/issues/7303)
+* adapt to deeplyFulfilled being async ([#6816](https://github.com/Agoric/agoric-sdk/issues/6816)) ([ec315e1](https://github.com/Agoric/agoric-sdk/commit/ec315e1634f6d5cdef1cddafc18777de7c04fecc))
+* **telemetry:** partially undo [#6684](https://github.com/Agoric/agoric-sdk/issues/6684) ([b9fa85b](https://github.com/Agoric/agoric-sdk/commit/b9fa85b7307124e50cc3a84d3b694307cde55f54))
+* avoid using top-level `require` ([57ca2db](https://github.com/Agoric/agoric-sdk/commit/57ca2dbfbadb373f97d43b2fb4e90302c9149976))
+* **types:** type assertion for assertAllDefined ([25f16b2](https://github.com/Agoric/agoric-sdk/commit/25f16b2e935931b81313d2ee1d491b305088bb7a))
+* track endo 1382 fix to 6570 ([#6612](https://github.com/Agoric/agoric-sdk/issues/6612)) ([7897761](https://github.com/Agoric/agoric-sdk/commit/7897761d6e19e6bbba42e7bd0bd5befb507afa08))
+
+
+
 ### [0.2.1](https://github.com/Agoric/agoric-sdk/compare/@agoric/internal@0.2.0...@agoric/internal@0.2.1) (2022-10-05)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/internal",
-  "version": "0.2.2-pismo-dev-0d5327f.0+0d5327f",
+  "version": "0.3.0",
   "description": "Externally unsupported utilities internal to agoric-sdk",
   "type": "module",
   "main": "src/index.js",
@@ -9,6 +9,8 @@
   },
   "scripts": {
     "build": "exit 0",
+    "prepack": "tsc --build jsconfig.build.json",
+    "postpack": "git clean -f '*.d.ts*'",
     "test": "ava",
     "test:nyc": "exit 0",
     "test:xs": "exit 0",
@@ -18,13 +20,19 @@
     "lint:types": "tsc -p jsconfig.json"
   },
   "dependencies": {
-    "@endo/eventual-send": "^0.16.5",
-    "@endo/marshal": "^0.7.5",
-    "@endo/promise-kit": "^0.2.49"
+    "@agoric/zone": "^0.2.0",
+    "@endo/far": "^0.2.18",
+    "@endo/marshal": "^0.8.5",
+    "@endo/patterns": "^0.2.2",
+    "@endo/promise-kit": "^0.2.56",
+    "@endo/stream": "^0.3.25",
+    "anylogger": "^0.21.0",
+    "jessie.js": "^0.3.2"
   },
   "devDependencies": {
-    "@endo/init": "^0.5.49",
-    "ava": "^4.3.1"
+    "@endo/init": "^0.5.56",
+    "ava": "^5.2.0",
+    "tsd": "^0.28.1"
   },
   "author": "Agoric",
   "license": "Apache-2.0",
@@ -34,5 +42,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "0d5327f87310cf523834853b0546d0e217f37009"
+  "gitHead": "ea8c1c64911b4c58fb43635b25e17e3d50d0cf2a"
 }

package/src/action-types.d.ts

@@ -0,0 +1,16 @@
+export const BOOTSTRAP_BLOCK: "BOOTSTRAP_BLOCK";
+export const COSMOS_SNAPSHOT: "COSMOS_SNAPSHOT";
+export const BEGIN_BLOCK: "BEGIN_BLOCK";
+export const CALCULATE_FEES_IN_BEANS: "CALCULATE_FEES_IN_BEANS";
+export const CORE_EVAL: "CORE_EVAL";
+export const DELIVER_INBOUND: "DELIVER_INBOUND";
+export const END_BLOCK: "END_BLOCK";
+export const COMMIT_BLOCK: "COMMIT_BLOCK";
+export const AFTER_COMMIT_BLOCK: "AFTER_COMMIT_BLOCK";
+export const IBC_EVENT: "IBC_EVENT";
+export const PLEASE_PROVISION: "PLEASE_PROVISION";
+export const VBANK_BALANCE_UPDATE: "VBANK_BALANCE_UPDATE";
+export const WALLET_ACTION: "WALLET_ACTION";
+export const WALLET_SPEND_ACTION: "WALLET_SPEND_ACTION";
+export const INSTALL_BUNDLE: "INSTALL_BUNDLE";
+//# sourceMappingURL=action-types.d.ts.map

package/src/action-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-types.d.ts","sourceRoot":"","sources":["action-types.js"],"names":[],"mappings":"AAEA,gDAAiD;AACjD,gDAAiD;AACjD,wCAAyC;AACzC,gEAAiE;AACjE,oCAAqC;AACrC,gDAAiD;AACjD,oCAAqC;AACrC,0CAA2C;AAC3C,sDAAuD;AACvD,oCAAqC;AACrC,kDAAmD;AACnD,0DAA2D;AAC3D,4CAA6C;AAC7C,wDAAyD;AACzD,8CAA+C"}

package/src/action-types.js

@@ -0,0 +1,17 @@
+// @jessie-check
+
+export const BOOTSTRAP_BLOCK = 'BOOTSTRAP_BLOCK';
+export const COSMOS_SNAPSHOT = 'COSMOS_SNAPSHOT';
+export const BEGIN_BLOCK = 'BEGIN_BLOCK';
+export const CALCULATE_FEES_IN_BEANS = 'CALCULATE_FEES_IN_BEANS';
+export const CORE_EVAL = 'CORE_EVAL';
+export const DELIVER_INBOUND = 'DELIVER_INBOUND';
+export const END_BLOCK = 'END_BLOCK';
+export const COMMIT_BLOCK = 'COMMIT_BLOCK';
+export const AFTER_COMMIT_BLOCK = 'AFTER_COMMIT_BLOCK';
+export const IBC_EVENT = 'IBC_EVENT';
+export const PLEASE_PROVISION = 'PLEASE_PROVISION';
+export const VBANK_BALANCE_UPDATE = 'VBANK_BALANCE_UPDATE';
+export const WALLET_ACTION = 'WALLET_ACTION';
+export const WALLET_SPEND_ACTION = 'WALLET_SPEND_ACTION';
+export const INSTALL_BUNDLE = 'INSTALL_BUNDLE';

package/src/batched-deliver.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @typedef {(message: any[], ackNum: number) => void} DeliverMessages
+ */
+/**
+ * @param {DeliverMessages} deliver
+ * @param {{ clearTimeout: NodeJS.clearTimeout, setTimeout: NodeJS.setTimeout }} io
+ * @param {number} batchTimeoutMs
+ */
+export function makeBatchedDeliver(deliver: DeliverMessages, { clearTimeout, setTimeout }: {
+    clearTimeout: NodeJS.clearTimeout;
+    setTimeout: NodeJS.setTimeout;
+}, batchTimeoutMs?: number): (newMessages: any[], ackNum: number) => void;
+export const DEFAULT_BATCH_TIMEOUT_MS: 1000;
+export type DeliverMessages = (message: any[], ackNum: number) => void;
+//# sourceMappingURL=batched-deliver.d.ts.map

package/src/batched-deliver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batched-deliver.d.ts","sourceRoot":"","sources":["batched-deliver.js"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;;;GAIG;AACH,4CAJW,eAAe,gCACf;IAAE,kCAAkC;IAAC,8BAA6B;CAAE,mBACpE,MAAM,gDAsChB;AA/CD,4CAA6C;wCAGtB,GAAG,EAAE,UAAU,MAAM,KAAK,IAAI"}

package/src/batched-deliver.js

@@ -0,0 +1,50 @@
+// @jessie-check
+
+export const DEFAULT_BATCH_TIMEOUT_MS = 1000;
+
+/**
+ * @typedef {(message: any[], ackNum: number) => void} DeliverMessages
+ */
+
+/**
+ * @param {DeliverMessages} deliver
+ * @param {{ clearTimeout: NodeJS.clearTimeout, setTimeout: NodeJS.setTimeout }} io
+ * @param {number} batchTimeoutMs
+ */
+export function makeBatchedDeliver(
+  deliver,
+  { clearTimeout, setTimeout },
+  batchTimeoutMs = DEFAULT_BATCH_TIMEOUT_MS,
+) {
+  let batchedMessages = [];
+  let latestAckNum = 0;
+  let deliverTimeout;
+
+  /**
+   * @type {DeliverMessages}
+   */
+  async function batchedDeliver(newMessages, ackNum) {
+    // If we have no existing messages, reset the deliver timeout.
+    //
+    // This defers sending an ack until the timeout expires or we have new
+    // messages.
+    if (!batchedMessages.length) {
+      clearTimeout(deliverTimeout);
+      deliverTimeout = setTimeout(() => {
+        // Transfer the batched messages to the deliver function.
+        const msgs = batchedMessages;
+        batchedMessages = [];
+        deliver(msgs, latestAckNum);
+      }, batchTimeoutMs);
+    }
+
+    // Add new messages to the batch.
+    batchedMessages.push(...newMessages);
+    if (ackNum > latestAckNum) {
+      // Increase the latest ack.
+      latestAckNum = ackNum;
+    }
+  }
+
+  return batchedDeliver;
+}

package/src/callback.d.ts

@@ -0,0 +1,23 @@
+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 function isCallback(callback: any): callback is import("./types").Callback<any>;
+export function prepareAttenuator<M extends PropertyKey>(zone: import('@agoric/zone').Zone, methodNames: M[], { interfaceGuard, tag }?: {
+    interfaceGuard?: InterfaceGuard | undefined;
+    tag?: string | undefined;
+}): (args_0: {
+    target?: any;
+    isSync?: boolean | undefined;
+    overrides?: { [K in M]?: import("./types").Callback<any> | null | undefined; } | undefined;
+}) => { [K_1 in M]: (this: any, ...args: unknown[]) => any; } & import("@endo/eventual-send").RemotableBrand<{}, { [K_1 in M]: (this: any, ...args: unknown[]) => any; }>;
+export function prepareGuardedAttenuator(zone: import('@agoric/zone').Zone, interfaceGuard: InterfaceGuard, opts?: {
+    tag?: string | undefined;
+} | undefined): MakeAttenuator<any>;
+export type MakeAttenuator<T> = MakeAttenuator<T>;
+export type Callback<I extends (...args: unknown[]) => any> = import('./types').Callback<I>;
+export type SyncCallback<I extends (...args: unknown[]) => any> = import('./types').SyncCallback<I>;
+export type Farable<T> = import('@endo/eventual-send').RemotableBrand<{}, T> & T;
+//# 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":"AAuDO,6CALiB,OAAO,EAAE,KAAK,GAAG,sFAWxC;AAWM,0CALiB,OAAO,EAAE,KAAK,GAAG,oGAWxC;AAaM,6DAPiB,OAAO,EAAE,KAAK,GAAG,2JAaxC;AAeM,yDATiB,OAAO,EAAE,KAAK,GAAG,2MAexC;AAiBM,2DAXiB,OAAO,EAAE,KAAK,GAAG,iOAoBxC;AAiBM,uDAXiB,OAAO,EAAE,KAAK,GAAG,iRAmBxC;AAOM,qCAHI,GAAG,+CAeb;AAcM,+DAPI,OAAO,cAAc,EAAE,IAAI;IAGL,cAAc;IAEtB,GAAG;;aAkEb,GAAG;;;2BAxDgB,GAAG,WAAW,OAAO,EAAE,KAAK,GAAG,4EAA/B,GAAG,WAAW,OAAO,EAAE,KAAK,GAAG,KA2FhE;AAWM,+CALI,OAAO,cAAc,EAAE,IAAI,kBAC3B,cAAc;;oCAYxB;;yCA5SuB,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;yBAGpB,OAAO,qBAAqB,EAAE,cAAc,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC"}

package/src/callback.js

@@ -0,0 +1,322 @@
+// @ts-check
+import { E } from '@endo/far';
+import { isObject, isPassableSymbol } from '@endo/marshal';
+
+const { Fail, quote: q } = assert;
+
+const { fromEntries } = Object;
+
+const { ownKeys: rawOwnKeys } = Reflect;
+const ownKeys =
+  /** @type {<T extends PropertyKey>(obj: {[K in T]?: unknown}) => T[]} */ (
+    rawOwnKeys
+  );
+
+/**
+ * @template T
+ * @typedef {(...args: Parameters<ReturnType<prepareAttenuator>>) => Farable<T>} MakeAttenuator
+ */
+
+/**
+ * @template {(...args: unknown[]) => any} I
+ * @typedef {import('./types').Callback<I>} Callback
+ */
+
+/**
+ * @template {(...args: unknown[]) => any} I
+ * @typedef {import('./types').SyncCallback<I>} SyncCallback
+ */
+
+/** @template T @typedef {import('@endo/eventual-send').RemotableBrand<{}, T> & T} Farable */
+
+/**
+ * @param {unknown} key
+ * @returns {key is PropertyKey} FIXME: should be just `PropertyKey` but TS
+ * complains it can't be used as an index type.
+ */
+const isPropertyKey = key => {
+  switch (typeof key) {
+    case 'string':
+    case 'number':
+    case 'symbol':
+      return true;
+    default:
+      return false;
+  }
+};
+
+/**
+ * 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, methodName, bound } = callback;
+  if (methodName === undefined) {
+    return target(...bound, ...args);
+  }
+  return target[methodName](...bound, ...args);
+};
+harden(callSync);
+
+/**
+ * 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, methodName, bound } = callback;
+  if (methodName === undefined) {
+    return E(target)(...bound, ...args);
+  }
+  return E(target)[methodName](...bound, ...args);
+};
+harden(callE);
+
+/**
+ * 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) => {
+  typeof target === 'function' ||
+    Fail`sync function callback target must be a function: ${target}`;
+  /** @type {unknown} */
+  const cb = harden({ target, bound, isSync: true });
+  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) => {
+  isObject(target) ||
+    Fail`function callback target must be a function presence: ${target}`;
+  /** @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) => {
+  isObject(target) ||
+    Fail`sync method callback target must be an object: ${target}`;
+  typeof methodName === 'string' ||
+    isPassableSymbol(methodName) ||
+    Fail`method name must be a string or passable symbol: ${methodName}`;
+  /** @type {unknown} */
+  const cb = harden({ target, methodName, bound, isSync: true });
+  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) => {
+  isObject(target) || Fail`method callback target must be an object: ${target}`;
+  typeof methodName === 'string' ||
+    isPassableSymbol(methodName) ||
+    Fail`method name must be a string or passable symbol: ${methodName}`;
+  /** @type {unknown} */
+  const cb = harden({ target, methodName, bound });
+  return /** @type {Callback<I>} */ (cb);
+};
+harden(makeMethodCallback);
+
+/**
+ * @param {any} callback
+ * @returns {callback is Callback<any>}
+ */
+export const isCallback = callback => {
+  if (!isObject(callback)) {
+    return false;
+  }
+  const { target, methodName, bound } = callback;
+  return (
+    isObject(target) &&
+    (methodName === undefined ||
+      typeof methodName === 'string' ||
+      isPassableSymbol(methodName)) &&
+    Array.isArray(bound)
+  );
+};
+harden(isCallback);
+
+/**
+ * Prepare an attenuator class whose methods can be redirected via callbacks.
+ *
+ * @template {PropertyKey} M
+ * @param {import('@agoric/zone').Zone} zone The zone in which to allocate attenuators.
+ * @param {M[]} methodNames Methods to forward.
+ * @param {object} opts
+ * @param {InterfaceGuard} [opts.interfaceGuard] An interface guard for the
+ * new attenuator.
+ * @param {string} [opts.tag] A tag for the new attenuator exoClass.
+ */
+export const prepareAttenuator = (
+  zone,
+  methodNames,
+  { interfaceGuard, tag = 'Attenuator' } = {},
+) => {
+  /**
+   * @typedef {(this: any, ...args: unknown[]) => any} Method
+   * @typedef {{ [K in M]?: Callback<any> | null}} Overrides
+   * @typedef {{ [K in M]: (this: any, ...args: unknown[]) => any }} Methods
+   */
+  const methods = /** @type {Methods} */ (
+    fromEntries(
+      methodNames.map(key => {
+        // Only allow the `PropertyKey` type for the target method key.
+        if (!isPropertyKey(key)) {
+          throw Fail`key ${q(key)} is not a PropertyKey`;
+        }
+
+        const m = /** @type {Methods} */ ({
+          // Explicitly use concise method syntax to preserve `this` but prevent
+          // constructor behavior.
+          /** @type {Method} */
+          [key](...args) {
+            // Support both synchronous and async callbacks.
+            const cb = this.state.cbs[key];
+            if (!cb) {
+              const err = assert.error(
+                `unimplemented ${q(tag)} method ${q(key)}`,
+              );
+              if (this.state.isSync) {
+                throw err;
+              }
+              return Promise.reject(err);
+            }
+            if (cb.isSync) {
+              return callSync(cb, ...args);
+            }
+            return callE(cb, ...args);
+          },
+        })[key];
+        return /** @type {const} */ ([key, m]);
+      }),
+    )
+  );
+
+  /**
+   * Create an exo object whose behavior is composed from a default target
+   * and/or individual method override callbacks.
+   *
+   * @param {object} opts
+   * @param {unknown} [opts.target] The target for any methods that
+   * weren't specified in `opts.overrides`.
+   * @param {boolean} [opts.isSync=false] Whether the target should be treated
+   * as synchronously available.
+   * @param {Overrides} [opts.overrides] Set individual
+   * callbacks for methods (whose names must be defined in the
+   * `prepareAttenuator` or `prepareGuardedAttenuator` call).  Nullish overrides
+   * mean to throw.
+   */
+  const makeAttenuator = zone.exoClass(
+    tag,
+    interfaceGuard,
+    /**
+     * @param {object} opts
+     * @param {any} [opts.target]
+     * @param {boolean} [opts.isSync=false]
+     * @param {Overrides} [opts.overrides]
+     */
+    ({
+      target = null,
+      isSync = false,
+      overrides = /** @type {Overrides} */ ({}),
+    }) => {
+      const cbs = /** @type {Overrides} */ ({});
+
+      const remaining = new Set(methodNames);
+      for (const key of ownKeys(overrides)) {
+        remaining.has(key) ||
+          Fail`${q(tag)} overrides[${q(key)}] not allowed by methodNames`;
+
+        remaining.delete(key);
+        const cb = overrides[key];
+        cb == null ||
+          isCallback(cb) ||
+          Fail`${q(tag)} overrides[${q(key)}] is not a callback; got ${cb}`;
+        cbs[key] = cb;
+      }
+      for (const key of remaining) {
+        if (isSync) {
+          cbs[key] = makeSyncMethodCallback(target, key);
+        } else {
+          cbs[key] = makeMethodCallback(target, key);
+        }
+      }
+      return harden({ cbs, isSync });
+    },
+    /** @type {Methods} */ (methods),
+  );
+  return makeAttenuator;
+};
+harden(prepareAttenuator);
+
+/**
+ * Prepare an attenuator whose methodNames are derived from the interfaceGuard.
+ *
+ * @param {import('@agoric/zone').Zone} zone
+ * @param {InterfaceGuard} interfaceGuard
+ * @param {object} [opts]
+ * @param {string} [opts.tag]
+ */
+export const prepareGuardedAttenuator = (zone, interfaceGuard, opts = {}) => {
+  const { methodGuards } = interfaceGuard;
+  const methodNames = ownKeys(methodGuards);
+  const makeAttenuator = prepareAttenuator(zone, methodNames, {
+    ...opts,
+    interfaceGuard,
+  });
+  return /** @type {MakeAttenuator<any>} */ (makeAttenuator);
+};
+harden(prepareGuardedAttenuator);

package/src/chain-storage-paths.d.ts

@@ -0,0 +1,16 @@
+/**
+ * These identify top-level paths for SwingSet chain storage
+ * (and serve as prefixes).
+ * To avoid collisions, they should remain synchronized with
+ * golang/cosmos/x/swingset/keeper/keeper.go
+ */
+export const ACTION_QUEUE: "actionQueue";
+export const HIGH_PRIORITY_QUEUE: "highPriorityQueue";
+export const HIGH_PRIORITY_SENDERS: "highPrioritySenders";
+export const BEANSOWING: "beansOwing";
+export const EGRESS: "egress";
+export const MAILBOX: "mailbox";
+export const BUNDLES: "bundles";
+export const CUSTOM: "published";
+export const SWING_STORE: "swingStore";
+//# sourceMappingURL=chain-storage-paths.d.ts.map

package/src/chain-storage-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-storage-paths.d.ts","sourceRoot":"","sources":["chain-storage-paths.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,yCAA0C;AAC1C,sDAAuD;AACvD,0DAA2D;AAC3D,sCAAuC;AACvC,8BAA+B;AAC/B,gCAAiC;AACjC,gCAAiC;AACjC,iCAAkC;AAClC,uCAAwC"}

package/src/chain-storage-paths.js

@@ -0,0 +1,17 @@
+// @jessie-check
+
+/**
+ * These identify top-level paths for SwingSet chain storage
+ * (and serve as prefixes).
+ * To avoid collisions, they should remain synchronized with
+ * golang/cosmos/x/swingset/keeper/keeper.go
+ */
+export const ACTION_QUEUE = 'actionQueue';
+export const HIGH_PRIORITY_QUEUE = 'highPriorityQueue';
+export const HIGH_PRIORITY_SENDERS = 'highPrioritySenders';
+export const BEANSOWING = 'beansOwing';
+export const EGRESS = 'egress';
+export const MAILBOX = 'mailbox';
+export const BUNDLES = 'bundles';
+export const CUSTOM = 'published';
+export const SWING_STORE = 'swingStore';

package/src/config.d.ts

@@ -0,0 +1,25 @@
+export namespace BridgeId {
+    const BANK: string;
+    const CORE: string;
+    const DIBC: string;
+    const STORAGE: string;
+    const PROVISION: string;
+    const PROVISION_SMART_WALLET: string;
+    const WALLET: string;
+}
+export namespace WalletName {
+    const depositFacet: string;
+}
+export namespace VBankAccount {
+    namespace reserve {
+        const module: string;
+        const address: string;
+    }
+    namespace provision {
+        const module_1: string;
+        export { module_1 as module };
+        const address_1: string;
+        export { address_1 as address };
+    }
+}
+//# sourceMappingURL=config.d.ts.map

package/src/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["config.js"],"names":[],"mappings":""}