polkadot-api 1.7.7 → 1.7.9

package/dist/index.js

@@ -125,11 +125,10 @@ const compatibilityHelper = (descriptors, getDescriptorEntryPoint, getRuntimeEnt
     descriptors,
     (threshold, runtime) => getCompatibilityLevel(runtime) >= threshold
   );
-  const waitDescriptors = () => descriptors;
-  const compatibleRuntime$ = (chainHead, hash) => rxjs.combineLatest([waitDescriptors(), chainHead.getRuntimeContext$(hash)]);
+  const compatibleRuntime$ = (chainHead, hash) => rxjs.combineLatest([descriptors, chainHead.getRuntimeContext$(hash)]);
   const withCompatibleRuntime = (chainHead, mapper) => (source$) => rxjs.combineLatest([
     source$.pipe(chainHead.withRuntime(mapper)),
-    waitDescriptors()
+    descriptors
   ]).pipe(rxjs.map(([[x, ctx], descriptors2]) => [x, descriptors2, ctx]));
   const argsAreCompatible = (descriptors2, ctx, args) => {
     if (descriptors2 instanceof RuntimeToken) return true;
@@ -161,7 +160,7 @@ const compatibilityHelper = (descriptors, getDescriptorEntryPoint, getRuntimeEnt
     isCompatible,
     getCompatibilityLevel,
     getCompatibilityLevels,
-    waitDescriptors,
+    descriptors,
     withCompatibleRuntime,
     compatibleRuntime$,
     argsAreCompatible,
@@ -180,7 +179,7 @@ const withOptionalToken = (compatibilityToken, fn) => (...args) => {
 
 const createConstantEntry = (palletName, name, {
   valuesAreCompatible,
-  waitDescriptors,
+  descriptors,
   isCompatible,
   getCompatibilityLevel
 }) => {
@@ -209,7 +208,7 @@ const createConstantEntry = (palletName, name, {
         );
       return value;
     }
-    return waitDescriptors().then(fn);
+    return descriptors.then(fn);
   };
   return Object.assign(fn, { isCompatible, getCompatibilityLevel });
 };
@@ -248,130 +247,46 @@ function firstValueFromWithSignal(source, signal) {
   });
 }
 
-const concatMapEager = (mapper, concurrent = Infinity) => (source$) => new rxjs.Observable((observer) => {
-  let topSubscription;
-  const queues = /* @__PURE__ */ new Map();
-  const innerSubscriptions = /* @__PURE__ */ new Map();
-  const results = /* @__PURE__ */ new Map();
-  let mapperIdx = 0;
-  let subscriptionIdx = 0;
-  let observerIdx = 0;
-  const nextSubscription = () => {
-    const inner$ = queues.get(subscriptionIdx);
-    if (!inner$) {
-      if (innerSubscriptions.size === 0 && (typeof topSubscription === "undefined" || topSubscription.closed)) {
-        observer.complete();
-      }
-      return;
-    }
-    const idx = subscriptionIdx++;
-    queues.delete(idx);
-    if (observerIdx !== idx) {
-      results.set(idx, []);
-    }
-    innerSubscriptions.set(
-      idx,
-      inner$.subscribe({
-        next(x) {
-          if (observerIdx === idx) {
-            observer.next(x);
-          } else {
-            results.get(idx).push(x);
-          }
-        },
-        complete() {
-          innerSubscriptions.delete(idx);
-          if (idx === observerIdx) {
-            observerIdx++;
-            while (results.has(observerIdx)) {
-              results.get(observerIdx).forEach((x) => observer.next(x));
-              results.delete(observerIdx);
-              if (innerSubscriptions.has(observerIdx)) {
-                break;
-              }
-              observerIdx++;
-            }
-          }
-          nextSubscription();
-        },
-        error(e) {
-          observer.error(e);
-        }
-      })
-    );
-  };
-  topSubscription = source$.subscribe({
-    next(outterValue) {
-      const idx = mapperIdx++;
-      queues.set(
-        idx,
-        rxjs.defer(() => mapper(outterValue, idx))
-      );
-      if (innerSubscriptions.size < concurrent) {
-        nextSubscription();
-      }
-    },
-    error(e) {
-      observer.error(e);
-    },
-    complete() {
-      if (innerSubscriptions.size === 0) {
-        observer.complete();
-      }
-    }
-  });
-  return () => {
-    innerSubscriptions.forEach((subscription) => subscription.unsubscribe());
-    topSubscription.unsubscribe();
-    queues.clear();
-    results.clear();
-  };
-});
-
-const raceMap = (mapper, concurrent) => (source$) => new rxjs.Observable((observer) => {
-  let innerSubscriptions = new Array();
-  let isOuterDone = false;
-  const createSubscription = (value) => {
-    const sub = new rxjs.Subscription();
-    innerSubscriptions.push(sub);
-    if (innerSubscriptions.length > concurrent) {
-      innerSubscriptions[0].unsubscribe();
-      innerSubscriptions = innerSubscriptions.slice(1);
-    }
-    const subscription = mapper(value).subscribe({
-      next(value2) {
-        const index = innerSubscriptions.indexOf(sub);
-        innerSubscriptions.slice(0, index).forEach((s) => s.unsubscribe());
-        innerSubscriptions = innerSubscriptions.slice(index);
-        observer.next(value2);
+const EMPTY_VALUE = Symbol("EMPTY_VALUE");
+const lossLessExhaustMap = (mapper) => (source$) => new rxjs.Observable((observer) => {
+  let innerSubscription = null;
+  let queuedValue = EMPTY_VALUE;
+  let isOutterDone = false;
+  const setInnerSubscription = () => {
+    const observable = mapper(queuedValue);
+    queuedValue = EMPTY_VALUE;
+    innerSubscription = observable.subscribe({
+      next(vv) {
+        observer.next(vv);
       },
-      error(error) {
-        observer.error(error);
+      error(ee) {
+        observer.error(ee);
       },
       complete() {
-        const index = innerSubscriptions.indexOf(sub);
-        innerSubscriptions.splice(index, 1);
-        if (innerSubscriptions.length === 0 && isOuterDone)
-          observer.complete();
+        if (queuedValue !== EMPTY_VALUE) setInnerSubscription();
+        else {
+          innerSubscription = null;
+          if (isOutterDone) observer.complete();
+        }
       }
     });
-    sub.add(subscription);
   };
-  const outerSubscription = source$.subscribe({
-    next(value) {
-      createSubscription(value);
+  const subscription = source$.subscribe({
+    next(v) {
+      queuedValue = v;
+      if (!innerSubscription) setInnerSubscription();
     },
-    error(err) {
-      observer.error(err);
+    error(e) {
+      observer.error(e);
     },
     complete() {
-      if (innerSubscriptions.length === 0) observer.complete();
-      isOuterDone = true;
+      if (!innerSubscription) observer.complete();
+      isOutterDone = true;
     }
   });
   return () => {
-    outerSubscription.unsubscribe();
-    innerSubscriptions.forEach((sub) => sub.unsubscribe());
+    innerSubscription?.unsubscribe();
+    subscription.unsubscribe();
   };
 });
 
@@ -420,7 +335,7 @@ const createEventEntry = (pallet, name, chainHead, {
       if (!argsAreCompatible(runtime, ctx, null)) throw compatibilityError();
       return [block, runtime, ctx];
     }),
-    concatMapEager(
+    observableClient.concatMapEager(
       ([block, runtime, ctx]) => chainHead.eventsAt$(block.hash).pipe(
         rxjs.map((events) => {
           const winners = events.filter(
@@ -486,12 +401,12 @@ const createRuntimeCallEntry = (api, method, chainHead, {
   return Object.assign(fn, { getCompatibilityLevel, isCompatible });
 };
 
+const toMapped = rxjs.map((x) => x.mapped);
 const createStorageEntry = (pallet, name, chainHead, {
   isCompatible,
   getCompatibilityLevel,
   getCompatibilityLevels,
-  waitDescriptors,
-  withCompatibleRuntime,
+  descriptors: descriptorsPromise,
   argsAreCompatible,
   valuesAreCompatible
 }) => {
@@ -513,48 +428,29 @@ const createStorageEntry = (pallet, name, chainHead, {
   const getCodec = (ctx) => {
     try {
       return ctx.dynamicBuilder.buildStorage(pallet, name);
-    } catch {
+    } catch (e) {
       throw new Error(`Runtime entry Storage(${pallet}.${name}) not found`);
     }
   };
   const watchValue = (...args) => {
     const target = args[args.length - 1];
-    const actualArgs = target === "best" || target === "finalized" ? args.slice(0, -1) : args;
-    if (isSystemNumber)
-      return chainHead.bestBlocks$.pipe(
-        rxjs.map((blocks) => blocks.at(target === "best" ? 0 : -1).number),
-        rxjs.distinctUntilChanged(),
-        bigIntOrNumber
-      );
-    return chainHead[target === "best" ? "best$" : "finalized$"].pipe(
-      rxjs.debounceTime(0),
-      withCompatibleRuntime(chainHead, (x) => x.hash),
-      raceMap(([block, runtime, ctx]) => {
-        const codecs = getCodec(ctx);
-        if (!argsAreCompatible(runtime, ctx, actualArgs))
-          throw incompatibleError();
-        return chainHead.storage$(block.hash, "value", () => codecs.enc(...actualArgs)).pipe(
-          rxjs.map((val) => {
-            if (!valuesAreCompatible(runtime, ctx, val))
-              throw incompatibleError();
-            return { val, codecs };
-          })
-        );
-      }, 4),
-      rxjs.distinctUntilChanged((a, b) => a.val === b.val),
-      rxjs.map(
-        ({ val, codecs }) => val === null ? codecs.fallback : codecs.dec(val)
-      )
+    const isBest = target === "best";
+    const actualArgs = isBest || target === "finalized" ? args.slice(0, -1) : args;
+    return chainHead[isBest ? "best$" : "finalized$"].pipe(
+      lossLessExhaustMap(
+        () => getRawValue$(...actualArgs, isBest ? { at: "best" } : {})
+      ),
+      rxjs.distinctUntilChanged((a, b) => a.raw === b.raw),
+      toMapped
     );
   };
-  const getValue = async (...args) => {
+  const getRawValue$ = (...args) => {
     const lastArg = args[args.length - 1];
     const isLastArgOptional = isOptionalArg(lastArg);
-    const { signal, at: _at } = isLastArgOptional ? lastArg : {};
+    const { at: _at } = isLastArgOptional ? lastArg : {};
     const at = _at ?? null;
-    let result$;
-    if (isSystemNumber) {
-      result$ = chainHead.bestBlocks$.pipe(
+    if (isSystemNumber)
+      return chainHead.bestBlocks$.pipe(
         rxjs.map((blocks) => {
           if (at === "finalized" || !at) return blocks.at(-1);
           if (at === "best") return blocks.at(0);
@@ -565,39 +461,50 @@ const createStorageEntry = (pallet, name, chainHead, {
           return block.number;
         }),
         rxjs.distinctUntilChanged(),
-        bigIntOrNumber
-      );
-    } else {
-      const descriptors = await waitDescriptors();
-      result$ = chainHead.storage$(
-        at,
-        "value",
-        (ctx) => {
-          const codecs = getCodec(ctx);
-          const actualArgs = args.length === codecs.len ? args : args.slice(0, -1);
-          if (args !== actualArgs && !isLastArgOptional) throw invalidArgs(args);
-          if (!argsAreCompatible(descriptors, ctx, actualArgs))
-            throw incompatibleError();
-          return codecs.enc(...actualArgs);
-        },
-        null,
-        (data, ctx) => {
-          const codecs = getCodec(ctx);
-          const value = data === null ? codecs.fallback : codecs.dec(data);
-          if (!valuesAreCompatible(descriptors, ctx, value))
-            throw incompatibleError();
-          return value;
-        }
+        bigIntOrNumber,
+        rxjs.map((mapped) => ({ raw: "", mapped }))
       );
-    }
-    return firstValueFromWithSignal(result$, signal);
+    return rxjs.from(descriptorsPromise).pipe(
+      rxjs.mergeMap(
+        (descriptors) => chainHead.storage$(
+          at,
+          "value",
+          (ctx) => {
+            const codecs = getCodec(ctx);
+            const actualArgs = args.length === codecs.len ? args : args.slice(0, -1);
+            if (args !== actualArgs && !isLastArgOptional)
+              throw invalidArgs(args);
+            if (!argsAreCompatible(descriptors, ctx, actualArgs))
+              throw incompatibleError();
+            return codecs.enc(...actualArgs);
+          },
+          null,
+          (data, ctx) => {
+            const codecs = getCodec(ctx);
+            const value = data === null ? codecs.fallback : codecs.dec(data);
+            if (!valuesAreCompatible(descriptors, ctx, value))
+              throw incompatibleError();
+            return value;
+          }
+        )
+      )
+    );
+  };
+  const getValue = async (...args) => {
+    const lastArg = args[args.length - 1];
+    const isLastArgOptional = isOptionalArg(lastArg);
+    const { signal } = isLastArgOptional ? lastArg : {};
+    return firstValueFromWithSignal(
+      getRawValue$(...args).pipe(toMapped),
+      signal
+    );
   };
   const getEntries = async (...args) => {
     const lastArg = args[args.length - 1];
     const isLastArgOptional = isOptionalArg(lastArg);
     const { signal, at: _at } = isLastArgOptional ? lastArg : {};
     const at = _at ?? null;
-    const descriptors = await waitDescriptors();
+    const descriptors = await descriptorsPromise;
     const result$ = chainHead.storage$(
       at,
       "descendantsValues",
@@ -624,7 +531,7 @@ const createStorageEntry = (pallet, name, chainHead, {
           throw incompatibleError();
         return decodedValues;
       }
-    );
+    ).pipe(toMapped);
     return firstValueFromWithSignal(result$, signal);
   };
   const getValues = (keyArgs, options) => Promise.all(