polkadot-api 0.0.0-prerelease-do-not-use

package/dist/index.mjs

@@ -0,0 +1,929 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/client.ts
+import {
+  createClient as createRawClient
+} from "@polkadot-api/substrate-client";
+import { firstValueFrom as firstValueFrom4 } from "rxjs";
+
+// src/constants.ts
+import { firstValueFrom, map as map2 } from "rxjs";
+
+// src/runtime.ts
+import { combineLatest, filter, map } from "rxjs";
+var Runtime = class {
+  constructor(ctx, checksums) {
+    __publicField(this, "_ctx");
+    __publicField(this, "_checksums");
+    this._ctx = ctx;
+    this._checksums = checksums;
+  }
+};
+function getRuntimeContext(runtime) {
+  return runtime._ctx;
+}
+function getImportedChecksum(runtime, idx) {
+  return runtime._checksums[idx];
+}
+var createRuntime = (ctx, checksums) => new Runtime(ctx, checksums);
+var getRuntimeApi = (checksums, chainHead) => {
+  let latestRuntime;
+  let resolve = null;
+  latestRuntime = new Promise((res) => {
+    resolve = res;
+  });
+  const runtimeWithChecksums$ = combineLatest([chainHead.runtime$, checksums]);
+  runtimeWithChecksums$.subscribe(([x, checksums2]) => {
+    if (x) {
+      if (resolve) {
+        resolve(createRuntime(x, checksums2));
+        resolve = null;
+      } else {
+        latestRuntime = Promise.resolve(createRuntime(x, checksums2));
+      }
+    } else if (!resolve) {
+      latestRuntime = new Promise((res) => {
+        resolve = res;
+      });
+    }
+  });
+  const result = runtimeWithChecksums$.pipe(
+    filter(([x]) => Boolean(x)),
+    map(([x, checksums2]) => createRuntime(x, checksums2))
+  );
+  result.latest = () => latestRuntime;
+  return result;
+};
+var compatibilityHelper = (runtimeApi, checksumIdx) => (getChecksum) => {
+  function isCompatibleSync(runtime) {
+    const ctx = getRuntimeContext(runtime);
+    const checksum = getImportedChecksum(runtime, checksumIdx);
+    return getChecksum(ctx) === checksum;
+  }
+  const isCompatible = (runtime) => {
+    if (runtime) {
+      return isCompatibleSync(runtime);
+    }
+    return runtimeApi.latest().then(isCompatibleSync);
+  };
+  const waitChecksums = async () => {
+    const runtime = await runtimeApi.latest();
+    return (ctx) => getChecksum(ctx) === getImportedChecksum(runtime, checksumIdx);
+  };
+  const compatibleRuntime$ = (chainHead, hash, error) => combineLatest([chainHead.getRuntimeContext$(hash), waitChecksums()]).pipe(
+    map(([ctx, isCompatible2]) => {
+      if (!isCompatible2(ctx)) {
+        throw error();
+      }
+      return ctx;
+    })
+  );
+  const withCompatibleRuntime = (chainHead, mapper, error) => (source$) => combineLatest([
+    source$.pipe(chainHead.withRuntime(mapper)),
+    waitChecksums()
+  ]).pipe(
+    map(([[x, ctx], isCompatible2]) => {
+      if (!isCompatible2(ctx)) {
+        throw error();
+      }
+      return [x, ctx];
+    })
+  );
+  return {
+    isCompatible,
+    waitChecksums,
+    withCompatibleRuntime,
+    compatibleRuntime$
+  };
+};
+
+// src/constants.ts
+var createConstantEntry = (palletName, name, chainHead, compatibilityHelper2) => {
+  const { isCompatible, compatibleRuntime$ } = compatibilityHelper2(
+    (ctx) => ctx.checksumBuilder.buildConstant(palletName, name)
+  );
+  const checksumError = () => new Error(`Incompatible runtime entry Constant(${palletName}.${name})`);
+  const cachedResults = /* @__PURE__ */ new WeakMap();
+  const getValueWithContext = (ctx) => {
+    if (cachedResults.has(ctx)) {
+      return cachedResults.get(ctx);
+    }
+    const pallet = ctx.metadata.pallets.find((p) => p.name === palletName);
+    const constant = pallet?.constants.find((c) => c.name === name);
+    const result = ctx.dynamicBuilder.buildConstant(palletName, name).dec(constant.value);
+    cachedResults.set(ctx, result);
+    return result;
+  };
+  const fn = (runtime) => {
+    if (runtime) {
+      if (!isCompatible(runtime))
+        throw checksumError();
+      return getValueWithContext(getRuntimeContext(runtime));
+    }
+    return firstValueFrom(
+      compatibleRuntime$(chainHead, null, checksumError).pipe(
+        map2(getValueWithContext)
+      )
+    );
+  };
+  return Object.assign(fn, { isCompatible });
+};
+
+// src/event.ts
+import { firstValueFrom as firstValueFrom2, map as map3, mergeMap } from "rxjs";
+
+// src/utils/shareLatest.ts
+import { ReplaySubject, share } from "rxjs";
+var shareLatest = share({
+  connector: () => new ReplaySubject(1),
+  resetOnError: true,
+  resetOnComplete: true,
+  resetOnRefCountZero: true
+});
+
+// src/utils/firstValueFromWithSignal.ts
+import { AbortError } from "@polkadot-api/utils";
+import { noop } from "rxjs";
+function firstValueFromWithSignal(source, signal) {
+  return new Promise((resolve, reject) => {
+    let subscription = null;
+    let isDone = false;
+    const onAbort = signal ? () => {
+      subscription?.unsubscribe();
+      reject(new AbortError());
+    } : noop;
+    subscription = source.subscribe({
+      next: (value) => {
+        resolve(value);
+        subscription?.unsubscribe();
+        isDone = true;
+      },
+      error: (e) => {
+        signal?.removeEventListener("abort", onAbort);
+        reject(e);
+      },
+      complete: () => {
+        signal?.removeEventListener("abort", onAbort);
+        reject(new Error("Observable completed without emitting"));
+      }
+    });
+    if (!isDone)
+      signal?.addEventListener("abort", onAbort);
+  });
+}
+
+// src/utils/concatMapEager.ts
+import { defer, Observable as Observable4 } from "rxjs";
+var concatMapEager = (mapper, concurrent = Infinity) => (source$) => new Observable4((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,
+        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();
+  };
+});
+
+// src/utils/lossLessExhaustMap.ts
+import { Observable as Observable5 } from "rxjs";
+var EMPTY_VALUE = Symbol("EMPTY_VALUE");
+var lossLessExhaustMap = (mapper) => (source$) => new Observable5((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(ee) {
+        observer.error(ee);
+      },
+      complete() {
+        if (queuedValue !== EMPTY_VALUE)
+          setInnerSubscription();
+        else {
+          innerSubscription = null;
+          if (isOutterDone)
+            observer.complete();
+        }
+      }
+    });
+  };
+  const subscription = source$.subscribe({
+    next(v) {
+      queuedValue = v;
+      if (!innerSubscription)
+        setInnerSubscription();
+    },
+    error(e) {
+      observer.error(e);
+    },
+    complete() {
+      if (!innerSubscription)
+        observer.complete();
+      isOutterDone = true;
+    }
+  });
+  return () => {
+    innerSubscription?.unsubscribe();
+    subscription.unsubscribe();
+  };
+});
+
+// src/event.ts
+var createEventEntry = (pallet, name, chainHead, compatibilityHelper2) => {
+  const { isCompatible, withCompatibleRuntime } = compatibilityHelper2(
+    (ctx) => ctx.checksumBuilder.buildEvent(pallet, name)
+  );
+  const checksumError = () => new Error(`Incompatible runtime entry Event(${pallet}.${name})`);
+  const shared$ = chainHead.finalized$.pipe(
+    withCompatibleRuntime(chainHead, (x) => x.hash, checksumError),
+    concatMapEager(
+      ([block]) => chainHead.eventsAt$(block.hash).pipe(
+        map3((events) => {
+          const winners = events.filter(
+            (e) => e.event.type === pallet && e.event.value.type === name
+          );
+          return winners.map((x) => {
+            return {
+              meta: {
+                phase: x.phase,
+                block
+              },
+              payload: x.event.value.value
+            };
+          });
+        })
+      )
+    ),
+    shareLatest
+  );
+  const watch = (f) => shared$.pipe(mergeMap((x) => f ? x.filter((d) => f(d.payload)) : x));
+  const pull = () => firstValueFrom2(shared$);
+  const filter2 = (events) => events.filter((e) => e.type === pallet && e.value.type === name).map((x) => x.value.value);
+  return { watch, pull, filter: filter2, isCompatible };
+};
+
+// src/client.ts
+import { getObservableClient } from "@polkadot-api/observable-client";
+
+// src/runtime-call.ts
+import { toHex } from "@polkadot-api/utils";
+import { map as map4, mergeMap as mergeMap2 } from "rxjs";
+var isOptionalArg = (lastArg) => {
+  if (typeof lastArg !== "object")
+    return false;
+  return Object.keys(lastArg).every(
+    (k) => k === "at" && typeof lastArg.at === "string" || k === "signal" && lastArg.signal instanceof AbortSignal
+  );
+};
+var createRuntimeCallEntry = (api, method, chainHead, compatibilityHelper2) => {
+  const { isCompatible, compatibleRuntime$ } = compatibilityHelper2(
+    (ctx) => ctx.checksumBuilder.buildRuntimeCall(api, method)
+  );
+  const callName = `${api}_${method}`;
+  const checksumError = () => new Error(`Incompatible runtime entry RuntimeCall(${callName})`);
+  const fn = (...args) => {
+    const lastArg = args[args.length - 1];
+    const isLastArgOptional = isOptionalArg(lastArg);
+    const { signal, at: _at } = isLastArgOptional ? lastArg : {};
+    const at = _at ?? null;
+    const result$ = compatibleRuntime$(chainHead, at, checksumError).pipe(
+      mergeMap2((ctx) => {
+        const codecs = ctx.dynamicBuilder.buildRuntimeCall(api, method);
+        return chainHead.call$(at, callName, toHex(codecs.args.enc(args))).pipe(map4(codecs.value.dec));
+      })
+    );
+    return firstValueFromWithSignal(result$, signal);
+  };
+  return Object.assign(fn, { isCompatible });
+};
+
+// src/storage.ts
+import { debounceTime, distinctUntilChanged, map as map5 } from "rxjs";
+var isOptionalArg2 = (lastArg) => {
+  if (typeof lastArg !== "object")
+    return false;
+  return Object.keys(lastArg).every(
+    (k) => k === "at" && typeof lastArg.at === "string" || k === "signal" && lastArg.signal instanceof AbortSignal
+  );
+};
+var createStorageEntry = (pallet, name, chainHead, compatibilityHelper2) => {
+  const { isCompatible, waitChecksums, withCompatibleRuntime } = compatibilityHelper2((ctx) => ctx.checksumBuilder.buildStorage(pallet, name));
+  const checksumError = () => new Error(`Incompatible runtime entry Storage(${pallet}.${name})`);
+  const invalidArgs = (args) => new Error(`Invalid Arguments calling ${pallet}.${name}(${args})`);
+  const watchValue = (...args) => {
+    const lastArg = args[args.length - 1];
+    const actualArgs = lastArg === "best" || lastArg === "finalized" ? args.slice(0, -1) : args;
+    return chainHead[lastArg === "best" ? "best$" : "finalized$"].pipe(
+      debounceTime(0),
+      withCompatibleRuntime(chainHead, (x) => x.hash, checksumError),
+      lossLessExhaustMap(([block, ctx]) => {
+        const codecs = ctx.dynamicBuilder.buildStorage(pallet, name);
+        return chainHead.storage$(block.hash, "value", () => codecs.enc(...actualArgs)).pipe(map5((val) => ({ val, codecs })));
+      }),
+      distinctUntilChanged((a, b) => a.val === b.val),
+      map5(
+        ({ val, codecs }) => val === null ? codecs.fallback : codecs.dec(val)
+      )
+    );
+  };
+  const getValue = async (...args) => {
+    const lastArg = args[args.length - 1];
+    const isLastArgOptional = isOptionalArg2(lastArg);
+    const { signal, at: _at } = isLastArgOptional ? lastArg : {};
+    const at = _at ?? null;
+    const isCompatible2 = await waitChecksums();
+    const result$ = chainHead.storage$(
+      at,
+      "value",
+      (ctx) => {
+        const codecs = ctx.dynamicBuilder.buildStorage(pallet, name);
+        const actualArgs = args.length === codecs.len ? args : args.slice(0, -1);
+        if (args !== actualArgs && !isLastArgOptional)
+          throw invalidArgs(args);
+        if (!isCompatible2(ctx))
+          throw checksumError();
+        return codecs.enc(...actualArgs);
+      },
+      null,
+      (data, ctx) => {
+        const codecs = ctx.dynamicBuilder.buildStorage(pallet, name);
+        return data === null ? codecs.fallback : codecs.dec(data);
+      }
+    );
+    return firstValueFromWithSignal(result$, signal);
+  };
+  const getEntries = async (...args) => {
+    const lastArg = args[args.length - 1];
+    const isLastArgOptional = isOptionalArg2(lastArg);
+    const { signal, at: _at } = isLastArgOptional ? lastArg : {};
+    const at = _at ?? null;
+    const isCompatible2 = await waitChecksums();
+    const result$ = chainHead.storage$(
+      at,
+      "descendantsValues",
+      (ctx) => {
+        const codecs = ctx.dynamicBuilder.buildStorage(pallet, name);
+        if (args.length > codecs.len)
+          throw invalidArgs(args);
+        const actualArgs = args.length > 0 && isLastArgOptional ? args.slice(0, -1) : args;
+        if (args.length === codecs.len && actualArgs === args)
+          throw invalidArgs(args);
+        if (!isCompatible2(ctx))
+          throw checksumError();
+        return codecs.enc(...actualArgs);
+      },
+      null,
+      (values, ctx) => {
+        const codecs = ctx.dynamicBuilder.buildStorage(pallet, name);
+        return values.map(({ key, value }) => ({
+          keyArgs: codecs.keyDecoder(key),
+          value: codecs.dec(value)
+        }));
+      }
+    );
+    return firstValueFromWithSignal(result$, signal);
+  };
+  const getValues = (keyArgs, options) => Promise.all(
+    keyArgs.map((args) => getValue(...options ? [...args, options] : args))
+  );
+  return { isCompatible, getValue, getValues, getEntries, watchValue };
+};
+
+// src/tx.ts
+import {
+  Binary,
+  Enum
+} from "@polkadot-api/substrate-bindings";
+import { mergeUint8, toHex as toHex2 } from "@polkadot-api/utils";
+import {
+  Observable as Observable8,
+  concat,
+  firstValueFrom as firstValueFrom3,
+  lastValueFrom,
+  map as map6,
+  mergeMap as mergeMap3,
+  of,
+  startWith,
+  take,
+  withLatestFrom
+} from "rxjs";
+var getTxSuccessFromSystemEvents = (systemEvents, txIdx) => {
+  const events = systemEvents.filter((x) => x.phase.type === "ApplyExtrinsic" && x.phase.value === txIdx).map((x) => x.event);
+  const lastEvent = events[events.length - 1];
+  const ok = lastEvent.type === "System" && lastEvent.value.type === "ExtrinsicSuccess";
+  return { ok, events };
+};
+var getSubmitFns = (chainHead, client) => {
+  const tx$ = (tx) => concat(
+    chainHead.finalized$.pipe(
+      take(1),
+      mergeMap3((finalized) => chainHead.validateTx$(tx, finalized.hash)),
+      map6((isValid) => {
+        if (!isValid)
+          throw new Error("Invalid");
+        return { type: "broadcasted" };
+      })
+    ),
+    new Observable8((observer) => {
+      const subscription = chainHead.trackTx$(tx).subscribe(observer);
+      subscription.add(
+        client.broadcastTx$(tx).subscribe({
+          error(e) {
+            observer.error(e);
+          }
+        })
+      );
+      return subscription;
+    })
+  );
+  const submit$ = (transaction) => tx$(transaction).pipe(
+    mergeMap3((result) => {
+      return result.type !== "finalized" ? of(result) : chainHead.eventsAt$(result.block.hash).pipe(
+        map6((events) => ({
+          ...result,
+          ...getTxSuccessFromSystemEvents(
+            events,
+            Number(result.block.index)
+          )
+        }))
+      );
+    })
+  );
+  const submit = async (transaction) => lastValueFrom(submit$(transaction)).then((x) => {
+    if (x.type !== "finalized")
+      throw null;
+    const result = { ...x };
+    delete result.type;
+    return result;
+  });
+  return { submit$, submit };
+};
+var createTxEntry = (pallet, name, assetChecksum, chainHead, submits, signer, compatibilityHelper2) => {
+  const { isCompatible, compatibleRuntime$ } = compatibilityHelper2(
+    (ctx) => ctx.checksumBuilder.buildCall(pallet, name)
+  );
+  const checksumError = () => new Error(`Incompatible runtime entry Tx(${pallet}.${name})`);
+  const fn = (arg) => {
+    const getCallDataWithContext = ({ dynamicBuilder, asset: [assetEnc, assetCheck] }, arg2, hinted = {}) => {
+      let returnHinted = hinted;
+      if (hinted.asset) {
+        if (assetChecksum !== assetCheck)
+          throw new Error(`Incompatible runtime asset`);
+        returnHinted = { ...hinted, asset: assetEnc(hinted.asset) };
+      }
+      const { location, codec } = dynamicBuilder.buildCall(pallet, name);
+      return {
+        callData: Binary.fromBytes(
+          mergeUint8(new Uint8Array(location), codec.enc(arg2))
+        ),
+        hinted: returnHinted
+      };
+    };
+    const getCallData$ = (arg2, hinted = {}) => compatibleRuntime$(chainHead, null, checksumError).pipe(
+      map6((ctx) => getCallDataWithContext(ctx, arg2, hinted))
+    );
+    const getEncodedData = (runtime) => {
+      if (runtime) {
+        if (!isCompatible(runtime)) {
+          throw checksumError();
+        }
+        return getCallDataWithContext(getRuntimeContext(runtime), arg).callData;
+      }
+      return firstValueFrom3(getCallData$(arg).pipe(map6((x) => x.callData)));
+    };
+    const sign$ = (from, _hinted) => getCallData$(arg, _hinted).pipe(
+      withLatestFrom(chainHead.finalized$),
+      take(1),
+      mergeMap3(
+        ([{ callData, hinted }, finalized]) => signer(from, callData.asBytes(), finalized, hinted)
+      )
+    );
+    const sign = (from, _hinted) => firstValueFrom3(sign$(from, _hinted)).then(toHex2);
+    const signAndSubmit = (from, _hinted) => sign(from, _hinted).then(submits.submit);
+    const signSubmitAndWatch = (from, _hinted) => sign$(from, _hinted).pipe(
+      mergeMap3((result) => {
+        const tx = toHex2(result);
+        return submits.submit$(tx).pipe(startWith({ type: "signed", tx }));
+      })
+    );
+    return {
+      decodedCall: Enum(pallet, Enum(name, arg)),
+      getEncodedData,
+      sign,
+      signSubmitAndWatch,
+      signAndSubmit
+    };
+  };
+  return Object.assign(fn, { isCompatible });
+};
+
+// src/get-create-tx.ts
+import { combineLatest as combineLatest2, mergeMap as mergeMap4, of as of6, take as take2 } from "rxjs";
+
+// src/signed-extensions/user/ChargeTransactionPayment.ts
+import { compactBn } from "@polkadot-api/substrate-bindings";
+import { of as of3 } from "rxjs";
+
+// src/signed-extensions/utils.ts
+import { map as map7, noop as noop2, of as of2 } from "rxjs";
+import {
+  Storage,
+  Twox64Concat,
+  u32
+} from "@polkadot-api/substrate-bindings";
+import { getDynamicBuilder, getLookupFn } from "@polkadot-api/metadata-builders";
+import { fromHex } from "@polkadot-api/utils";
+var empty = new Uint8Array();
+var genesisHashStorageKey = Storage("System")("BlockHash", noop2, [
+  u32,
+  Twox64Concat
+]).enc(0);
+var genesisHashFromCtx = (ctx) => ctx.chainHead.storage$(ctx.at, "value", () => genesisHashStorageKey, null).pipe(map7((result) => fromHex(result)));
+var systemVersionProp$ = (propName, metadata) => {
+  const lookupFn = getLookupFn(metadata.lookup);
+  const dynamicBuilder = getDynamicBuilder(metadata);
+  const constant = metadata.pallets.find((x) => x.name === "System").constants.find((s) => s.name === "Version");
+  const systemVersion = lookupFn(constant.type);
+  const systemVersionDec = dynamicBuilder.buildDefinition(constant.type).dec;
+  if (systemVersion.type !== "struct")
+    throw new Error("not a struct");
+  const valueEnc = dynamicBuilder.buildDefinition(
+    systemVersion.value[propName].id
+  ).enc;
+  return of2(valueEnc(systemVersionDec(constant.value)[propName]));
+};
+
+// src/signed-extensions/user/ChargeTransactionPayment.ts
+var ChargeTransactionPayment = (tip) => of3({
+  value: compactBn.enc(tip),
+  additionalSigned: empty
+});
+
+// src/signed-extensions/user/CheckMortality.ts
+import { map as map8, of as of4 } from "rxjs";
+import { Bytes, enhanceEncoder, u16 } from "@polkadot-api/substrate-bindings";
+import { fromHex as fromHex2 } from "@polkadot-api/utils";
+function trailingZeroes(n) {
+  let i = 0;
+  while (!(n & 1)) {
+    i++;
+    n >>= 1;
+  }
+  return i;
+}
+var mortal = enhanceEncoder(
+  Bytes(2).enc,
+  (value) => {
+    const factor = Math.max(value.period >> 12, 1);
+    const left = Math.min(Math.max(trailingZeroes(value.period) - 1, 1), 15);
+    const right = value.phase / factor << 4;
+    return u16.enc(left | right);
+  }
+);
+var zero = new Uint8Array([0]);
+var CheckMortality = (input, ctx) => {
+  if (!input)
+    return genesisHashFromCtx(ctx).pipe(
+      map8((additionalSigned) => ({
+        additionalSigned,
+        value: zero
+      }))
+    );
+  const { period, blockNumber } = input;
+  return of4({
+    additionalSigned: fromHex2(ctx.at),
+    value: mortal({
+      period,
+      phase: blockNumber % period
+    })
+  });
+};
+
+// src/signed-extensions/user/ChargeAssetTxPayment.ts
+import { of as of5 } from "rxjs";
+import {
+  Bytes as Bytes2,
+  Option,
+  Struct,
+  compact
+} from "@polkadot-api/substrate-bindings";
+var encoder = Struct({
+  tip: compact,
+  asset: Option(Bytes2(Infinity))
+}).enc;
+var ChargeAssetTxPayment = (tip, asset) => of5({
+  value: encoder({
+    tip,
+    asset
+  }),
+  additionalSigned: empty
+});
+
+// src/signed-extensions/chain/index.ts
+var chain_exports = {};
+__export(chain_exports, {
+  CheckGenesis: () => CheckGenesis,
+  CheckNonce: () => CheckNonce,
+  CheckSpecVersion: () => CheckSpecVersion,
+  CheckTxVersion: () => CheckTxVersion
+});
+
+// src/signed-extensions/chain/CheckGenesis.ts
+import { map as map9 } from "rxjs";
+var CheckGenesis = (ctx) => genesisHashFromCtx(ctx).pipe(
+  map9((additionalSigned) => ({ value: empty, additionalSigned }))
+);
+
+// src/signed-extensions/chain/CheckNonce.ts
+import { map as map10 } from "rxjs";
+import { compact as compact2, u16 as u162, u32 as u322, u64, u8 } from "@polkadot-api/substrate-bindings";
+import { fromHex as fromHex3, toHex as toHex3 } from "@polkadot-api/utils";
+var lenToDecoder = {
+  1: u8.dec,
+  2: u162.dec,
+  4: u322.dec,
+  8: u64.dec
+};
+var CheckNonce = (ctx) => ctx.chainHead.call$(ctx.at, "AccountNonceApi_account_nonce", toHex3(ctx.from)).pipe(
+  map10((result) => {
+    const bytes = fromHex3(result);
+    const decoder = lenToDecoder[bytes.length];
+    if (!decoder)
+      throw new Error("AccountNonceApi_account_nonce retrieved wrong data");
+    return compact2.enc(decoder(bytes));
+  }),
+  map10((value) => ({ value, additionalSigned: empty }))
+);
+
+// src/signed-extensions/chain/CheckSpecVersion.ts
+import { map as map11 } from "rxjs";
+var CheckSpecVersion = ({ metadata }) => systemVersionProp$("spec_version", metadata).pipe(
+  map11((additionalSigned) => ({ additionalSigned, value: empty }))
+);
+
+// src/signed-extensions/chain/CheckTxVersion.ts
+import { map as map12 } from "rxjs";
+var CheckTxVersion = ({ metadata }) => systemVersionProp$("transaction_version", metadata).pipe(
+  map12((additionalSigned) => ({ additionalSigned, value: empty }))
+);
+
+// src/get-create-tx.ts
+import { _void } from "@polkadot-api/substrate-bindings";
+var getCreateTx = (chainHead) => {
+  return (signer, callData, atBlock, hinted) => {
+    return chainHead.getRuntimeContext$(atBlock.hash).pipe(
+      take2(1),
+      mergeMap4((ctx) => {
+        const signedExtensionsCtx = {
+          metadata: ctx.metadata,
+          chainHead,
+          callData,
+          at: atBlock.hash,
+          from: signer.publicKey
+        };
+        const mortality = hinted?.mortality?.mortal ? { period: hinted.mortality.period, blockNumber: atBlock.number } : void 0;
+        return combineLatest2(
+          ctx.metadata.extrinsic.signedExtensions.map(
+            ({ identifier, type, additionalSigned }) => {
+              if (identifier === "CheckMortality")
+                return CheckMortality(mortality, signedExtensionsCtx);
+              if (identifier === "ChargeTransactionPayment")
+                return ChargeTransactionPayment(hinted?.tip ?? 0n);
+              if (identifier === "ChargeAssetTxPayment")
+                return ChargeAssetTxPayment(hinted?.tip ?? 0n, hinted?.asset);
+              const fn = chain_exports[identifier];
+              if (!fn) {
+                if (ctx.dynamicBuilder.buildDefinition(type) === _void && ctx.dynamicBuilder.buildDefinition(additionalSigned) === _void)
+                  return of6({
+                    value: empty,
+                    additionalSigned: empty
+                  });
+                throw new Error(`Unsupported signed-extension: ${identifier}`);
+              }
+              return fn(signedExtensionsCtx);
+            }
+          )
+        ).pipe(
+          mergeMap4(
+            (signedExtensions) => signer.sign(
+              callData,
+              Object.fromEntries(
+                ctx.metadata.extrinsic.signedExtensions.map(
+                  ({ identifier }, idx) => [
+                    identifier,
+                    { identifier, ...signedExtensions[idx] }
+                  ]
+                )
+              ),
+              ctx.metadataRaw,
+              atBlock.number
+            )
+          )
+        );
+      })
+    );
+  };
+};
+
+// src/client.ts
+var createTypedApi = (descriptors, createTxFromSigner, chainHead, submitFns) => {
+  const runtimeApi = getRuntimeApi(descriptors.checksums, chainHead);
+  const { pallets, apis: runtimeApis } = descriptors;
+  const query = {};
+  for (const pallet in pallets) {
+    query[pallet] || (query[pallet] = {});
+    const [stgEntries] = pallets[pallet];
+    for (const name in stgEntries) {
+      query[pallet][name] = createStorageEntry(
+        pallet,
+        name,
+        chainHead,
+        compatibilityHelper(runtimeApi, stgEntries[name])
+      );
+    }
+  }
+  const tx = {};
+  for (const pallet in pallets) {
+    tx[pallet] || (tx[pallet] = {});
+    const [, txEntries] = pallets[pallet];
+    for (const name in txEntries) {
+      tx[pallet][name] = createTxEntry(
+        pallet,
+        name,
+        descriptors.asset,
+        chainHead,
+        submitFns,
+        createTxFromSigner,
+        compatibilityHelper(runtimeApi, txEntries[name])
+      );
+    }
+  }
+  const events = {};
+  for (const pallet in pallets) {
+    events[pallet] || (events[pallet] = {});
+    const [, , evEntries] = pallets[pallet];
+    for (const name in evEntries) {
+      events[pallet][name] = createEventEntry(
+        pallet,
+        name,
+        chainHead,
+        compatibilityHelper(runtimeApi, evEntries[name])
+      );
+    }
+  }
+  const constants = {};
+  for (const pallet in pallets) {
+    constants[pallet] || (constants[pallet] = {});
+    const [, , , , ctEntries] = pallets[pallet];
+    for (const name in ctEntries) {
+      constants[pallet][name] = createConstantEntry(
+        pallet,
+        name,
+        chainHead,
+        compatibilityHelper(runtimeApi, ctEntries[name])
+      );
+    }
+  }
+  const apis = {};
+  for (const api in runtimeApis) {
+    apis[api] || (apis[api] = {});
+    const methods = runtimeApis[api];
+    for (const method in methods) {
+      apis[api][method] = createRuntimeCallEntry(
+        api,
+        method,
+        chainHead,
+        compatibilityHelper(runtimeApi, methods[method])
+      );
+    }
+  }
+  return {
+    query,
+    tx,
+    event: events,
+    apis,
+    constants,
+    runtime: runtimeApi
+  };
+};
+function createClient(provider) {
+  const rawClient = createRawClient(provider);
+  const client = getObservableClient(rawClient);
+  const chainHead = client.chainHead$();
+  const createTxFromSigner = getCreateTx(chainHead);
+  const submitFns = getSubmitFns(chainHead, client);
+  const { submit, submit$: submitAndWatch } = submitFns;
+  return {
+    finalized$: chainHead.finalized$,
+    bestBlocks$: chainHead.bestBlocks$,
+    getBlockHeader: (hash) => firstValueFrom4(chainHead.header$(hash ?? null)),
+    getBlockBody: chainHead.body$,
+    destroy: () => {
+      chainHead.unfollow();
+      client.destroy();
+    },
+    submit,
+    submitAndWatch,
+    getTypedApi: (descriptors) => createTypedApi(descriptors, createTxFromSigner, chainHead, submitFns)
+  };
+}
+
+// src/re-exports.ts
+import {
+  AccountId,
+  Binary as Binary2,
+  Enum as Enum2,
+  _Enum
+} from "@polkadot-api/substrate-bindings";
+export {
+  AccountId,
+  Binary2 as Binary,
+  Enum2 as Enum,
+  _Enum,
+  createClient
+};
+//# sourceMappingURL=index.mjs.map