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

package/dist/index.js

@@ -0,0 +1,916 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AccountId: () => import_substrate_bindings8.AccountId,
+  Binary: () => import_substrate_bindings8.Binary,
+  Enum: () => import_substrate_bindings8.Enum,
+  _Enum: () => import_substrate_bindings8._Enum,
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/client.ts
+var import_substrate_client = require("@polkadot-api/substrate-client");
+var import_rxjs20 = require("rxjs");
+
+// src/constants.ts
+var import_rxjs2 = require("rxjs");
+
+// src/runtime.ts
+var import_rxjs = require("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$ = (0, import_rxjs.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(
+    (0, import_rxjs.filter)(([x]) => Boolean(x)),
+    (0, import_rxjs.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) => (0, import_rxjs.combineLatest)([chainHead.getRuntimeContext$(hash), waitChecksums()]).pipe(
+    (0, import_rxjs.map)(([ctx, isCompatible2]) => {
+      if (!isCompatible2(ctx)) {
+        throw error();
+      }
+      return ctx;
+    })
+  );
+  const withCompatibleRuntime = (chainHead, mapper, error) => (source$) => (0, import_rxjs.combineLatest)([
+    source$.pipe(chainHead.withRuntime(mapper)),
+    waitChecksums()
+  ]).pipe(
+    (0, import_rxjs.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 (0, import_rxjs2.firstValueFrom)(
+      compatibleRuntime$(chainHead, null, checksumError).pipe(
+        (0, import_rxjs2.map)(getValueWithContext)
+      )
+    );
+  };
+  return Object.assign(fn, { isCompatible });
+};
+
+// src/event.ts
+var import_rxjs7 = require("rxjs");
+
+// src/utils/shareLatest.ts
+var import_rxjs3 = require("rxjs");
+var shareLatest = (0, import_rxjs3.share)({
+  connector: () => new import_rxjs3.ReplaySubject(1),
+  resetOnError: true,
+  resetOnComplete: true,
+  resetOnRefCountZero: true
+});
+
+// src/utils/firstValueFromWithSignal.ts
+var import_utils = require("@polkadot-api/utils");
+var import_rxjs4 = require("rxjs");
+function firstValueFromWithSignal(source, signal) {
+  return new Promise((resolve, reject) => {
+    let subscription = null;
+    let isDone = false;
+    const onAbort = signal ? () => {
+      subscription?.unsubscribe();
+      reject(new import_utils.AbortError());
+    } : import_rxjs4.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
+var import_rxjs5 = require("rxjs");
+var concatMapEager = (mapper, concurrent = Infinity) => (source$) => new import_rxjs5.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,
+        (0, import_rxjs5.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
+var import_rxjs6 = require("rxjs");
+var EMPTY_VALUE = Symbol("EMPTY_VALUE");
+var lossLessExhaustMap = (mapper) => (source$) => new import_rxjs6.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(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(
+        (0, import_rxjs7.map)((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((0, import_rxjs7.mergeMap)((x) => f ? x.filter((d) => f(d.payload)) : x));
+  const pull = () => (0, import_rxjs7.firstValueFrom)(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
+var import_observable_client = require("@polkadot-api/observable-client");
+
+// src/runtime-call.ts
+var import_utils4 = require("@polkadot-api/utils");
+var import_rxjs8 = require("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(
+      (0, import_rxjs8.mergeMap)((ctx) => {
+        const codecs = ctx.dynamicBuilder.buildRuntimeCall(api, method);
+        return chainHead.call$(at, callName, (0, import_utils4.toHex)(codecs.args.enc(args))).pipe((0, import_rxjs8.map)(codecs.value.dec));
+      })
+    );
+    return firstValueFromWithSignal(result$, signal);
+  };
+  return Object.assign(fn, { isCompatible });
+};
+
+// src/storage.ts
+var import_rxjs9 = require("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(
+      (0, import_rxjs9.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((0, import_rxjs9.map)((val) => ({ val, codecs })));
+      }),
+      (0, import_rxjs9.distinctUntilChanged)((a, b) => a.val === b.val),
+      (0, import_rxjs9.map)(
+        ({ 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
+var import_substrate_bindings = require("@polkadot-api/substrate-bindings");
+var import_utils6 = require("@polkadot-api/utils");
+var import_rxjs10 = require("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) => (0, import_rxjs10.concat)(
+    chainHead.finalized$.pipe(
+      (0, import_rxjs10.take)(1),
+      (0, import_rxjs10.mergeMap)((finalized) => chainHead.validateTx$(tx, finalized.hash)),
+      (0, import_rxjs10.map)((isValid) => {
+        if (!isValid)
+          throw new Error("Invalid");
+        return { type: "broadcasted" };
+      })
+    ),
+    new import_rxjs10.Observable((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(
+    (0, import_rxjs10.mergeMap)((result) => {
+      return result.type !== "finalized" ? (0, import_rxjs10.of)(result) : chainHead.eventsAt$(result.block.hash).pipe(
+        (0, import_rxjs10.map)((events) => ({
+          ...result,
+          ...getTxSuccessFromSystemEvents(
+            events,
+            Number(result.block.index)
+          )
+        }))
+      );
+    })
+  );
+  const submit = async (transaction) => (0, import_rxjs10.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: import_substrate_bindings.Binary.fromBytes(
+          (0, import_utils6.mergeUint8)(new Uint8Array(location), codec.enc(arg2))
+        ),
+        hinted: returnHinted
+      };
+    };
+    const getCallData$ = (arg2, hinted = {}) => compatibleRuntime$(chainHead, null, checksumError).pipe(
+      (0, import_rxjs10.map)((ctx) => getCallDataWithContext(ctx, arg2, hinted))
+    );
+    const getEncodedData = (runtime) => {
+      if (runtime) {
+        if (!isCompatible(runtime)) {
+          throw checksumError();
+        }
+        return getCallDataWithContext(getRuntimeContext(runtime), arg).callData;
+      }
+      return (0, import_rxjs10.firstValueFrom)(getCallData$(arg).pipe((0, import_rxjs10.map)((x) => x.callData)));
+    };
+    const sign$ = (from, _hinted) => getCallData$(arg, _hinted).pipe(
+      (0, import_rxjs10.withLatestFrom)(chainHead.finalized$),
+      (0, import_rxjs10.take)(1),
+      (0, import_rxjs10.mergeMap)(
+        ([{ callData, hinted }, finalized]) => signer(from, callData.asBytes(), finalized, hinted)
+      )
+    );
+    const sign = (from, _hinted) => (0, import_rxjs10.firstValueFrom)(sign$(from, _hinted)).then(import_utils6.toHex);
+    const signAndSubmit = (from, _hinted) => sign(from, _hinted).then(submits.submit);
+    const signSubmitAndWatch = (from, _hinted) => sign$(from, _hinted).pipe(
+      (0, import_rxjs10.mergeMap)((result) => {
+        const tx = (0, import_utils6.toHex)(result);
+        return submits.submit$(tx).pipe((0, import_rxjs10.startWith)({ type: "signed", tx }));
+      })
+    );
+    return {
+      decodedCall: (0, import_substrate_bindings.Enum)(pallet, (0, import_substrate_bindings.Enum)(name, arg)),
+      getEncodedData,
+      sign,
+      signSubmitAndWatch,
+      signAndSubmit
+    };
+  };
+  return Object.assign(fn, { isCompatible });
+};
+
+// src/get-create-tx.ts
+var import_rxjs19 = require("rxjs");
+
+// src/signed-extensions/user/ChargeTransactionPayment.ts
+var import_substrate_bindings3 = require("@polkadot-api/substrate-bindings");
+var import_rxjs12 = require("rxjs");
+
+// src/signed-extensions/utils.ts
+var import_rxjs11 = require("rxjs");
+var import_substrate_bindings2 = require("@polkadot-api/substrate-bindings");
+var import_metadata_builders = require("@polkadot-api/metadata-builders");
+var import_utils7 = require("@polkadot-api/utils");
+var empty = new Uint8Array();
+var genesisHashStorageKey = (0, import_substrate_bindings2.Storage)("System")("BlockHash", import_rxjs11.noop, [
+  import_substrate_bindings2.u32,
+  import_substrate_bindings2.Twox64Concat
+]).enc(0);
+var genesisHashFromCtx = (ctx) => ctx.chainHead.storage$(ctx.at, "value", () => genesisHashStorageKey, null).pipe((0, import_rxjs11.map)((result) => (0, import_utils7.fromHex)(result)));
+var systemVersionProp$ = (propName, metadata) => {
+  const lookupFn = (0, import_metadata_builders.getLookupFn)(metadata.lookup);
+  const dynamicBuilder = (0, import_metadata_builders.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 (0, import_rxjs11.of)(valueEnc(systemVersionDec(constant.value)[propName]));
+};
+
+// src/signed-extensions/user/ChargeTransactionPayment.ts
+var ChargeTransactionPayment = (tip) => (0, import_rxjs12.of)({
+  value: import_substrate_bindings3.compactBn.enc(tip),
+  additionalSigned: empty
+});
+
+// src/signed-extensions/user/CheckMortality.ts
+var import_rxjs13 = require("rxjs");
+var import_substrate_bindings4 = require("@polkadot-api/substrate-bindings");
+var import_utils9 = require("@polkadot-api/utils");
+function trailingZeroes(n) {
+  let i = 0;
+  while (!(n & 1)) {
+    i++;
+    n >>= 1;
+  }
+  return i;
+}
+var mortal = (0, import_substrate_bindings4.enhanceEncoder)(
+  (0, import_substrate_bindings4.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 import_substrate_bindings4.u16.enc(left | right);
+  }
+);
+var zero = new Uint8Array([0]);
+var CheckMortality = (input, ctx) => {
+  if (!input)
+    return genesisHashFromCtx(ctx).pipe(
+      (0, import_rxjs13.map)((additionalSigned) => ({
+        additionalSigned,
+        value: zero
+      }))
+    );
+  const { period, blockNumber } = input;
+  return (0, import_rxjs13.of)({
+    additionalSigned: (0, import_utils9.fromHex)(ctx.at),
+    value: mortal({
+      period,
+      phase: blockNumber % period
+    })
+  });
+};
+
+// src/signed-extensions/user/ChargeAssetTxPayment.ts
+var import_rxjs14 = require("rxjs");
+var import_substrate_bindings5 = require("@polkadot-api/substrate-bindings");
+var encoder = (0, import_substrate_bindings5.Struct)({
+  tip: import_substrate_bindings5.compact,
+  asset: (0, import_substrate_bindings5.Option)((0, import_substrate_bindings5.Bytes)(Infinity))
+}).enc;
+var ChargeAssetTxPayment = (tip, asset) => (0, import_rxjs14.of)({
+  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
+var import_rxjs15 = require("rxjs");
+var CheckGenesis = (ctx) => genesisHashFromCtx(ctx).pipe(
+  (0, import_rxjs15.map)((additionalSigned) => ({ value: empty, additionalSigned }))
+);
+
+// src/signed-extensions/chain/CheckNonce.ts
+var import_rxjs16 = require("rxjs");
+var import_substrate_bindings6 = require("@polkadot-api/substrate-bindings");
+var import_utils14 = require("@polkadot-api/utils");
+var lenToDecoder = {
+  1: import_substrate_bindings6.u8.dec,
+  2: import_substrate_bindings6.u16.dec,
+  4: import_substrate_bindings6.u32.dec,
+  8: import_substrate_bindings6.u64.dec
+};
+var CheckNonce = (ctx) => ctx.chainHead.call$(ctx.at, "AccountNonceApi_account_nonce", (0, import_utils14.toHex)(ctx.from)).pipe(
+  (0, import_rxjs16.map)((result) => {
+    const bytes = (0, import_utils14.fromHex)(result);
+    const decoder = lenToDecoder[bytes.length];
+    if (!decoder)
+      throw new Error("AccountNonceApi_account_nonce retrieved wrong data");
+    return import_substrate_bindings6.compact.enc(decoder(bytes));
+  }),
+  (0, import_rxjs16.map)((value) => ({ value, additionalSigned: empty }))
+);
+
+// src/signed-extensions/chain/CheckSpecVersion.ts
+var import_rxjs17 = require("rxjs");
+var CheckSpecVersion = ({ metadata }) => systemVersionProp$("spec_version", metadata).pipe(
+  (0, import_rxjs17.map)((additionalSigned) => ({ additionalSigned, value: empty }))
+);
+
+// src/signed-extensions/chain/CheckTxVersion.ts
+var import_rxjs18 = require("rxjs");
+var CheckTxVersion = ({ metadata }) => systemVersionProp$("transaction_version", metadata).pipe(
+  (0, import_rxjs18.map)((additionalSigned) => ({ additionalSigned, value: empty }))
+);
+
+// src/get-create-tx.ts
+var import_substrate_bindings7 = require("@polkadot-api/substrate-bindings");
+var getCreateTx = (chainHead) => {
+  return (signer, callData, atBlock, hinted) => {
+    return chainHead.getRuntimeContext$(atBlock.hash).pipe(
+      (0, import_rxjs19.take)(1),
+      (0, import_rxjs19.mergeMap)((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 (0, import_rxjs19.combineLatest)(
+          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) === import_substrate_bindings7._void && ctx.dynamicBuilder.buildDefinition(additionalSigned) === import_substrate_bindings7._void)
+                  return (0, import_rxjs19.of)({
+                    value: empty,
+                    additionalSigned: empty
+                  });
+                throw new Error(`Unsupported signed-extension: ${identifier}`);
+              }
+              return fn(signedExtensionsCtx);
+            }
+          )
+        ).pipe(
+          (0, import_rxjs19.mergeMap)(
+            (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 = (0, import_substrate_client.createClient)(provider);
+  const client = (0, import_observable_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) => (0, import_rxjs20.firstValueFrom)(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
+var import_substrate_bindings8 = require("@polkadot-api/substrate-bindings");
+//# sourceMappingURL=index.js.map