@agoric/casting 0.3.5-pismo-dev-0d5327f.0 → 0.4.1-dev-bf4b59f.0

package/src/follower-cosmjs.js

@@ -1,38 +1,33 @@
-// @ts-check
 /// <reference types="ses"/>
-/* eslint-disable no-await-in-loop, no-continue, @jessie.js/no-nested-await */
+/* eslint-disable no-await-in-loop, @jessie.js/no-nested-await */
 
 import { E, Far } from '@endo/far';
-import * as tendermintRpcStar from '@cosmjs/tendermint-rpc';
+import * as tendermint34 from '@cosmjs/tendermint-rpc';
 import * as stargateStar from '@cosmjs/stargate';
 
+import { isStreamCell } from '@agoric/internal/src/lib-chainStorage.js';
+
 import { MAKE_DEFAULT_DECODER, MAKE_DEFAULT_UNSERIALIZER } from './defaults.js';
 import { makeCastingSpec } from './casting-spec.js';
 import { makeLeader as defaultMakeLeader } from './leader-netconfig.js';
 
 const { QueryClient } = stargateStar;
-const { Tendermint34Client } = tendermintRpcStar;
-const { details: X, quote: q } = assert;
+const { Tendermint34Client } = tendermint34;
+const { details: X, quote: q, Fail } = assert;
 const textDecoder = new TextDecoder();
 
-/** @template T @typedef {import('./types.js').StreamCell<T>} StreamCell */
-/** @template T @typedef {import('./types.js').ValueFollowerElement<T>} ValueFollowerElement */
-/** @template T @typedef {import('./types.js').Follower<ValueFollowerElement<T>>} ValueFollower */
+/** @template T @typedef {import('./types.js').Follower<import('./types.js').ValueFollowerElement<T>>} ValueFollower */
 
+// Copied from https://github.com/cosmos/cosmjs/pull/1328/files until release
 /**
- * This is an imperfect heuristic to navigate the migration from value cells to
- * stream cells.
- * At time of writing, no legacy cells have the same shape as a stream cell,
- * and we do not intend to create any more legacy value cells.
- *
- * @param {any} cell
+ * @typedef {{
+ *   readonly value: Uint8Array;
+ *   readonly height: number;
+ * }} QueryStoreResponse
+ * The response of an ABCI query to Tendermint.
+ * This is a subset of `tendermint34.AbciQueryResponse` in order
+ * to abstract away Tendermint versions.
  */
-const isStreamCell = cell =>
-  cell &&
-  typeof cell === 'object' &&
-  Array.isArray(cell.values) &&
-  typeof cell.blockHeight === 'string' &&
-  /^0$|^[1-9][0-9]*$/.test(cell.blockHeight);
 
 /**
  * @param {Uint8Array} a
@@ -52,6 +47,22 @@ const arrayEqual = (a, b) => {
 
 const defaultDataPrefixBytes = new Uint8Array();
 
+/**
+ * @param {Uint8Array} prefixedData
+ * @param {Uint8Array} prefix
+ */
+const stripPrefix = (prefixedData, prefix) => {
+  assert(
+    prefixedData.length >= prefix.length,
+    X`result too short for data prefix ${prefix}`,
+  );
+  assert(
+    arrayEqual(prefixedData.subarray(0, prefix.length), prefix),
+    X`${prefixedData} doesn't start with data prefix ${prefix}`,
+  );
+  return prefixedData.slice(prefix.length);
+};
+
 /**
  * @template T
  * @param {Iterable<T>} values
@@ -103,12 +114,11 @@ export const makeCosmjsFollower = (
     if (crasher) {
       E(crasher)
         .crash(`PROOF VERIFICATION FAILURE; crashing follower`, err)
-        .catch(e => assert.fail(X`crashing follower failed: ${e}`));
+        .catch(e => Fail`crashing follower failed: ${e}`);
     }
     throw err;
   };
-
-  assert(proofs.includes(proof), X`unrecognized follower proof mode ${proof}`);
+  proofs.includes(proof) || Fail`unrecognized follower proof mode ${proof}`;
 
   const where = 'CosmJS follower';
   const castingSpecP = makeCastingSpec(sourceP);
@@ -119,7 +129,7 @@ export const makeCosmjsFollower = (
   const tendermintClientPs = new Map();
   /**
    * @param {string} endpoint
-   * @returns {tendermintRpcStar.Tendermint34Client}
+   * @returns {tendermint34.Tendermint34Client}
    */
   const provideTendermintClient = endpoint => {
     let clientP = tendermintClientPs.get(endpoint);
@@ -130,17 +140,6 @@ export const makeCosmjsFollower = (
     return clientP;
   };
 
-  const getBlockHeight = async () => {
-    const values = await E(leader).mapEndpoints(where, async endpoint => {
-      const client = await provideTendermintClient(endpoint);
-      const info = await client.abciInfo();
-      const { lastBlockHeight } = info;
-      assert.typeof(lastBlockHeight, 'number');
-      return lastBlockHeight;
-    });
-    return collectSingle(values);
-  };
-
   /** @type {Map<string, import('@cosmjs/stargate').QueryClient>} */
   const endpointToQueryClient = new Map();
 
@@ -162,24 +161,23 @@ export const makeCosmjsFollower = (
   };
 
   /**
-   * @param {(endpoint: string, storeName: string, storeSubkey: Uint8Array) => Promise<Uint8Array>} tryGetPrefixedData
+   * @param {(endpoint: string, storeName: string, storeSubkey: Uint8Array) => Promise<QueryStoreResponse>} tryGetPrefixedData
+   * @returns {Promise<QueryStoreResponse>}
    */
-  const retryGetDataAndStripPrefix = async tryGetPrefixedData => {
+  const retryGetPrefixedData = async tryGetPrefixedData => {
     const {
       storeName,
       storeSubkey,
       dataPrefixBytes = defaultDataPrefixBytes,
+      noDataValue,
     } = await castingSpecP;
 
-    assert.typeof(
-      storeName,
-      'string',
-      X`storeName must be a string, got ${storeName}`,
-    );
-    assert(
-      storeSubkey,
-      X`storeSubkey must be a Uint8Array, got ${storeSubkey}`,
-    );
+    if (typeof storeName !== 'string') {
+      throw Fail`storeName must be a string, got ${storeName}`;
+    }
+    if (!storeSubkey) {
+      throw Fail`storeSubkey must be a Uint8Array, got ${storeSubkey}`;
+    }
 
     // mapEndpoints is our retry loop.
     const values = await E(leader).mapEndpoints(where, async endpoint =>
@@ -199,60 +197,47 @@ export const makeCosmjsFollower = (
     }
     assert(result);
 
-    if (result.length === 0) {
-      // No data.
-      return result;
+    /** @type {Uint8Array} */
+    let value;
+    if (result.value.length === 0) {
+      value = result.value;
+    } else if (noDataValue && arrayEqual(result.value, noDataValue)) {
+      value = new Uint8Array();
+    } else {
+      value = stripPrefix(result.value, dataPrefixBytes);
     }
-
-    // Handle the data prefix if any.
-    assert(
-      result.length >= dataPrefixBytes.length,
-      X`result too short for data prefix ${dataPrefixBytes}`,
-    );
-    assert(
-      arrayEqual(result.subarray(0, dataPrefixBytes.length), dataPrefixBytes),
-      X`${result} doesn't start with data prefix ${dataPrefixBytes}`,
-    );
-    return result.slice(dataPrefixBytes.length);
+    return { value, height: result.height };
   };
 
   /**
    * @param {number} [height]
-   * @returns {Promise<Uint8Array>}
+   * @returns {Promise<QueryStoreResponse>}
    */
   const getProvenDataAtHeight = async height => {
-    return retryGetDataAndStripPrefix(
-      async (endpoint, storeName, storeSubkey) => {
-        const queryClient = await provideQueryClient(endpoint);
-        return E(queryClient).queryVerified(storeName, storeSubkey, height);
-      },
-    );
+    return retryGetPrefixedData(async (endpoint, storeName, storeSubkey) => {
+      const queryClient = await provideQueryClient(endpoint);
+      return E(queryClient).queryStoreVerified(storeName, storeSubkey, height);
+    });
   };
 
   /**
-   * @param {number} height
+   * @param {number} [height] desired height, or the latest height if not set
+   * @returns {Promise<QueryStoreResponse>}
    */
   const getUnprovenDataAtHeight = async height => {
-    return retryGetDataAndStripPrefix(
-      async (endpoint, storeName, storeSubkey) => {
-        const client = await provideTendermintClient(endpoint);
-        const response = await client.abciQuery({
-          path: `store/${storeName}/key`,
-          data: storeSubkey,
-          height,
-          prove: false,
-        });
-        if (response.code !== 0) {
-          throw new Error(`Tendermint ABCI query failed: ${response.log}`);
-        }
-        const { value } = response;
-        return value;
-      },
-    );
+    return retryGetPrefixedData(async (endpoint, storeName, storeSubkey) => {
+      const queryClient = await provideQueryClient(endpoint);
+      return E(queryClient).queryAbci(
+        `store/${storeName}/key`,
+        storeSubkey,
+        height,
+      );
+    });
   };
 
   /**
-   * @param {number} blockHeight
+   * @param {number} [blockHeight] desired height, or the latest height if not set
+   * @returns {Promise<QueryStoreResponse>}
    */
   const tryGetDataAtHeight = async blockHeight => {
     if (proof === 'strict') {
@@ -262,36 +247,33 @@ export const makeCosmjsFollower = (
       // Fast and loose.
       return getUnprovenDataAtHeight(blockHeight);
     } else if (proof === 'optimistic') {
-      const allegedData = await getUnprovenDataAtHeight(blockHeight);
+      const alleged = await getUnprovenDataAtHeight(blockHeight);
 
       // Prove later, since it may take time we say we can't afford.
-      getProvenDataAtHeight(blockHeight).then(provenData => {
-        if (arrayEqual(provenData, allegedData)) {
+      getProvenDataAtHeight(alleged.height).then(proven => {
+        if (arrayEqual(proven.value, alleged.value)) {
           return;
         }
         crash(
           assert.error(
-            X`Alleged value ${allegedData} did not match proof ${provenData}`,
+            X`Alleged value ${alleged.value} did not match proof ${proven.value}`,
           ),
         );
       }, crash);
 
       // Speculate that we got the right value.
-      return allegedData;
+      return alleged;
     }
 
-    assert.fail(
-      X`Unrecognized proof option ${q(
-        proof,
-      )}, must be one of strict, none, or optimistic`,
-    );
+    throw Fail`Unrecognized proof option ${q(
+      proof,
+    )}, must be one of strict, none, or optimistic`;
   };
 
   /**
-   * @param {number} blockHeight
+   * @param {number} [blockHeight] desired height, or the latest height if not set
    */
   const getDataAtHeight = async blockHeight => {
-    assert.typeof(blockHeight, 'number');
     for (let attempt = 0; ; attempt += 1) {
       try {
         // AWAIT
@@ -341,7 +323,7 @@ export const makeCosmjsFollower = (
    * @param {any} data
    * @param {number} blockHeight
    * @param {number} currentBlockHeight
-   * @returns {Promise<ValueFollowerElement<T>>}
+   * @returns {Promise<import('./types.js').ValueFollowerElement<T>>}
    */
   const followerElementFromStreamCellValue = async (
     data,
@@ -350,13 +332,13 @@ export const makeCosmjsFollower = (
   ) => {
     // AWAIT
     const value = await /** @type {T} */ (
-      unserializer ? E(unserializer).unserialize(data) : data
+      unserializer ? E(unserializer).fromCapData(data) : data
     );
     return { value, blockHeight, currentBlockHeight };
   };
 
   /**
-   * @param {StreamCell<T>} streamCell
+   * @param {import('./types.js').StreamCell<T>} streamCell
    * @param {number} currentBlockHeight
    * @yields {ValueFollowerElement<T>}
    */
@@ -371,7 +353,7 @@ export const makeCosmjsFollower = (
   }
 
   /**
-   * @param {StreamCell<T>} streamCell
+   * @param {import('./types.js').StreamCell<T>} streamCell
    * @param {number} currentBlockHeight
    * @yields {ValueFollowerElement<T>}
    */
@@ -386,7 +368,7 @@ export const makeCosmjsFollower = (
   }
 
   /**
-   * @param {StreamCell<T>} streamCell
+   * @param {import('./types.js').StreamCell<T>} streamCell
    * @param {number} currentBlockHeight
    * @yields {ValueFollowerElement<T>}
    */
@@ -406,53 +388,51 @@ export const makeCosmjsFollower = (
    * @yields {ValueFollowerElement<T>}
    */
   async function* getLatestIterable() {
-    let blockHeight;
-    let data;
+    /** @type {number | undefined} the last known latest height */
+    let lastHeight;
+    let lastValue;
     for (;;) {
-      const currentBlockHeight = await getBlockHeight();
-      if (currentBlockHeight === blockHeight) {
+      const latest = await getDataAtHeight();
+      if (lastHeight && latest.height <= lastHeight) {
+        // Wait for a fresh block
         // TODO Long-poll for next block
         // https://github.com/Agoric/agoric-sdk/issues/6154
         await E(leader).jitter(where);
         continue;
       }
 
-      const currentData = await getDataAtHeight(currentBlockHeight);
-      if (currentData.length === 0) {
+      if (latest.value.length === 0) {
+        // No value, so try again
         // TODO Long-poll for block data change
         // https://github.com/Agoric/agoric-sdk/issues/6154
         await E(leader).jitter(where);
         continue;
       }
-      const currentStreamCell = streamCellForData(
-        currentBlockHeight,
-        currentData,
-      );
+      const currentStreamCell = streamCellForData(latest.height, latest.value);
 
-      blockHeight = currentBlockHeight;
+      lastHeight = latest.height;
 
       // Ignore adjacent duplicates.
       // This can only occur for legacy cells.
       // It is possible that the data changed from and back to the last
       // sampled data, but ignoring intermediate changes is consistent with
       // the semantics of getLatestIterable.
-      if (data !== undefined && arrayEqual(data, currentData)) {
+      if (lastValue !== undefined && arrayEqual(lastValue, latest.value)) {
         continue;
       }
       // However, streamCells that vacillate will reemit, since each iteration
       // at a unique block height is considered distinct.
 
-      yield* lastValueFromCell(currentStreamCell, currentBlockHeight);
-      data = currentData;
+      yield* lastValueFromCell(currentStreamCell, latest.height);
+      lastValue = latest.value;
     }
   }
 
   /**
-   * @param {number} cursorBlockHeight
+   * @param {number} [cursorBlockHeight]
    * @yields {ValueFollowerElement<T>}
    */
   async function* getEachIterableAtHeight(cursorBlockHeight) {
-    assert.typeof(cursorBlockHeight, 'number');
     // Track the data for the last emitted cell (the cell at the
     // cursorBlockHeight) so we know not to emit duplicates
     // of that cell.
@@ -462,7 +442,9 @@ export const makeCosmjsFollower = (
     // If the block has no corresponding data, wait for the first block to
     // contain data.
     for (;;) {
-      cursorData = await getDataAtHeight(cursorBlockHeight);
+      ({ value: cursorData, height: cursorBlockHeight } = await getDataAtHeight(
+        cursorBlockHeight,
+      ));
       if (cursorData.length !== 0) {
         const cursorStreamCell = streamCellForData(
           cursorBlockHeight,
@@ -474,21 +456,11 @@ export const makeCosmjsFollower = (
       // TODO Long-poll for next block
       // https://github.com/Agoric/agoric-sdk/issues/6154
       await E(leader).jitter(where);
-      cursorBlockHeight = await getBlockHeight();
     }
 
     // For each subsequent iteration, yield every value that has been
     // published since the last iteration and advance the cursor.
     for (;;) {
-      const currentBlockHeight = await getBlockHeight();
-      // Wait until the chain has added at least one block.
-      if (currentBlockHeight <= cursorBlockHeight) {
-        // TODO Long-poll for next block
-        // https://github.com/Agoric/agoric-sdk/issues/6154
-        await E(leader).jitter(where);
-        continue;
-      }
-
       // Scan backward for all changes since the last observed block and yield
       // them in forward order.
       // Stream cells allow us to skip blocks that did not change.
@@ -496,24 +468,27 @@ export const makeCosmjsFollower = (
       // the value for cells that changed.
       // This does imply accumulating a potentially large number of values if
       // the eachIterable gets sampled infrequently.
-      let rightBlockHeight = currentBlockHeight;
-      let rightData = await getDataAtHeight(rightBlockHeight);
-      if (rightData.length === 0) {
+      let { value: rightData, height: rightBlockHeight } =
+        await getDataAtHeight();
+      if (rightBlockHeight <= cursorBlockHeight || rightData.length === 0) {
         // TODO Long-poll for next block
         // https://github.com/Agoric/agoric-sdk/issues/6154
         await E(leader).jitter(where);
         continue;
       }
+
       let rightStreamCell = streamCellForData(rightBlockHeight, rightData);
 
       // Compare block cell data pairwise (left, right) and accumulate
       // a stack of each cell we encounter.
       const currentData = rightData;
+      const currentBlockHeight = rightBlockHeight;
+
       const cells = [];
       while (rightBlockHeight > cursorBlockHeight) {
         if (rightStreamCell.blockHeight > rightBlockHeight) {
           const { storeName, storeSubkey } = await castingSpecP;
-          throw new Error(
+          throw Error(
             `Corrupt storage cell for ${storeName} under key ${storeSubkey} at block-height ${rightBlockHeight} claims to being published at a later block height ${rightStreamCell.blockHeight}`,
           );
         }
@@ -522,7 +497,7 @@ export const makeCosmjsFollower = (
         if (leftBlockHeight <= cursorBlockHeight) {
           break;
         }
-        const leftData = await getDataAtHeight(leftBlockHeight);
+        const leftData = (await getDataAtHeight(leftBlockHeight)).value;
         // Do not scan behind a cell with no data.
         // This should not happen but can be tolerated.
         if (leftData.length === 0) {
@@ -570,7 +545,7 @@ export const makeCosmjsFollower = (
   }
 
   /**
-   * @param {number} cursorBlockHeight
+   * @param {number} [cursorBlockHeight]
    * @yields {ValueFollowerElement<T>}
    */
   async function* getReverseIterableAtHeight(cursorBlockHeight) {
@@ -578,8 +553,10 @@ export const makeCosmjsFollower = (
     // cursorBlockHeight) so we know not to emit duplicates
     // of that cell.
     let cursorData;
-    while (cursorBlockHeight > 0) {
-      cursorData = await getDataAtHeight(cursorBlockHeight);
+    while (cursorBlockHeight === undefined || cursorBlockHeight > 0) {
+      ({ value: cursorData, height: cursorBlockHeight } = await getDataAtHeight(
+        cursorBlockHeight,
+      ));
       if (cursorData.length === 0) {
         // No data at the cursor height, so signal beginning of stream.
         return;
@@ -596,15 +573,9 @@ export const makeCosmjsFollower = (
       return getLatestIterable();
     },
     async getEachIterable({ height = undefined } = {}) {
-      if (height === undefined) {
-        height = await getBlockHeight();
-      }
       return getEachIterableAtHeight(height);
     },
     async getReverseIterable({ height = undefined } = {}) {
-      if (height === undefined) {
-        height = await getBlockHeight();
-      }
       return getReverseIterableAtHeight(height);
     },
   });

package/src/follower.d.ts

@@ -0,0 +1,2 @@
+export function makeFollower<T>(specP: ERef<import('./types').CastingSpec> | string, leaderOrMaker?: import("./types").LeaderOrMaker | undefined, options?: import("./types").FollowerOptions | undefined): Promise<import("./follower-cosmjs.js").ValueFollower<T>>;
+//# sourceMappingURL=follower.d.ts.map

package/src/follower.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"follower.d.ts","sourceRoot":"","sources":["follower.js"],"names":[],"mappings":"AA4DO,uCALI,KAAK,OAAO,SAAS,EAAE,WAAW,CAAC,GAAG,MAAM,kLAYtD"}

package/src/follower.js

@@ -1,10 +1,10 @@
-// @ts-check
+// @jessie-check
 
 import { Far } from '@endo/far';
 import {
   mapAsyncIterable,
-  makeNotifierIterable,
-  makeSubscriptionIterable,
+  subscribeEach,
+  subscribeLatest,
 } from './iterable.js';
 import { makeCosmjsFollower } from './follower-cosmjs.js';
 import { makeCastingSpec } from './casting-spec.js';
@@ -22,10 +22,10 @@ const makeSubscriptionFollower = spec => {
       const { notifier, subscription } = await spec;
       let ai;
       if (notifier) {
-        ai = makeNotifierIterable(notifier);
+        ai = subscribeLatest(notifier);
       } else {
         assert(subscription);
-        ai = makeSubscriptionIterable(subscription);
+        ai = subscribeEach(subscription);
       }
       return mapAsyncIterable(ai, transform);
     },
@@ -34,10 +34,10 @@ const makeSubscriptionFollower = spec => {
       const { notifier, subscription } = await spec;
       let ai;
       if (subscription) {
-        ai = makeSubscriptionIterable(subscription);
+        ai = subscribeEach(subscription);
       } else {
         assert(notifier);
-        ai = makeNotifierIterable(notifier);
+        ai = subscribeLatest(notifier);
       }
       return mapAsyncIterable(ai, transform);
     },

package/src/iterable.d.ts

@@ -0,0 +1,24 @@
+export function mapAsyncIterable<TIn, TOut>(iterable: AsyncIterable<TIn>, transform: (value: TIn) => TOut): AsyncIterable<TOut>;
+export function iterateLatest<T>(follower: ERef<import("./types").Follower<T>>): {
+    /** @returns {AsyncIterator<T>} */
+    [Symbol.asyncIterator]: () => AsyncIterator<T, any, undefined>;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    /** @returns {AsyncIterator<T>} */
+    [Symbol.asyncIterator]: () => AsyncIterator<T, any, undefined>;
+}>;
+export function iterateEach<T>(follower: ERef<import("./types").Follower<T>>, options?: import("./types").IterateEachOptions | undefined): {
+    /** @returns {AsyncIterator<T>} */
+    [Symbol.asyncIterator]: () => AsyncIterator<T, any, undefined>;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    /** @returns {AsyncIterator<T>} */
+    [Symbol.asyncIterator]: () => AsyncIterator<T, any, undefined>;
+}>;
+export function iterateReverse<T>(follower: ERef<import("./types").Follower<T>>, options?: import("./types").IterateEachOptions | undefined): {
+    /** @returns {AsyncIterator<T>} */
+    [Symbol.asyncIterator]: () => AsyncIterator<T, any, undefined>;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    /** @returns {AsyncIterator<T>} */
+    [Symbol.asyncIterator]: () => AsyncIterator<T, any, undefined>;
+}>;
+export { subscribeEach, subscribeLatest } from "@agoric/notifier/subscribe.js";
+//# sourceMappingURL=iterable.d.ts.map

package/src/iterable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterable.d.ts","sourceRoot":"","sources":["iterable.js"],"names":[],"mappings":"AAWO,gIAON;AAQM;IAGH,kCAAkC;;;IAAlC,kCAAkC;;GAQlC;AASG;IAGH,kCAAkC;;;IAAlC,kCAAkC;;GAQlC;AAOG;IAGH,kCAAkC;;;IAAlC,kCAAkC;;GAQlC"}

package/src/iterable.js

@@ -1,48 +1,6 @@
-// @ts-check
 import { E, Far } from '@endo/far';
-import { makeNotifier } from '@agoric/notifier';
 
-/**
- * @template T
- * @param {ERef<Notifier<T>>} notifier
- * @returns {ConsistentAsyncIterable<T>}
- */
-export const makeNotifierIterable = notifier =>
-  makeNotifier(E(notifier).getSharableNotifierInternals());
-
-/**
- * TODO: Remove this function when we have `makePublisherKit`.
- *
- * @template T
- * @param {ERef<PublicationRecord<T>>} tailP
- * @returns {AsyncIterator<T>}
- */
-const makeSubscriptionIterator = tailP => {
-  // To understand the implementation, start with
-  // https://web.archive.org/web/20160404122250/http://wiki.ecmascript.org/doku.php?id=strawman:concurrency#infinite_queue
-  return Far('SubscriptionIterator', {
-    next: async () => {
-      const resultP = E.get(tailP).head;
-      tailP = E.get(tailP).tail;
-      return resultP;
-    },
-  });
-};
-
-/**
- * TODO: Remove this function when we have `makePublisherKit`.
- *
- * @template T
- * @param {ERef<Subscription<T>>} subscription
- * @returns {ConsistentAsyncIterable<T>}
- */
-export const makeSubscriptionIterable = subscription =>
-  harden({
-    [Symbol.asyncIterator]: () =>
-      makeSubscriptionIterator(
-        E(subscription).getSharableSubscriptionInternals(),
-      ),
-  });
+export { subscribeEach, subscribeLatest } from '@agoric/notifier/subscribe.js';
 
 /**
  * @template TIn
@@ -61,7 +19,7 @@ export const mapAsyncIterable = (iterable, transform) => {
 };
 
 /**
- * TODO: Remove this function when we have `makePublisherKit`.
+ * TODO: Remove this function when we have an @endo/publish-kit that suppports pull topics
  *
  * @template T
  * @param {ERef<import('./types').Follower<T>>} follower
@@ -80,7 +38,7 @@ export const iterateLatest = follower =>
   });
 
 /**
- * TODO: Remove this function when we have `makePublisherKit`.
+ * TODO: Remove this function when we have an @endo/publish-kit that suppports pull topics
  *
  * @template T
  * @param {ERef<import('./types.js').Follower<T>>} follower

package/src/leader-netconfig.d.ts

@@ -0,0 +1,4 @@
+export function makeLeaderFromRpcAddresses(rpcAddrs: string[], leaderOptions?: import("./types.js").LeaderOptions | undefined): import('./types.js').Leader;
+export function makeLeaderFromNetworkConfig(netconfigURL: string, options?: import("./types.js").LeaderOptions | undefined): Promise<any>;
+export function makeLeader(bootstrap?: string | undefined, options?: import("./types.js").LeaderOptions | undefined): ERef<import('./types.js').Leader>;
+//# sourceMappingURL=leader-netconfig.d.ts.map

package/src/leader-netconfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leader-netconfig.d.ts","sourceRoot":"","sources":["leader-netconfig.js"],"names":[],"mappings":"AAgBO,qDAJI,MAAM,EAAE,mEAEN,OAAO,YAAY,EAAE,MAAM,CAevC;AAMM,0DAHI,MAAM,0EAoChB;AAOM,sHAFM,KAAK,OAAO,YAAY,EAAE,MAAM,CAAC,CAO7C"}