polkadot-api 1.3.3 → 1.4.1

package/dist/index.d.ts

@@ -66,9 +66,13 @@ type EventsFromPalletsDef<T extends PalletsTypedef<any, any, any, any, any>> = E
 type ErrorsFromPalletsDef<T extends PalletsTypedef<any, any, any, any, any>> = ExtractPlain<T["__error"]>;
 type ConstFromPalletsDef<T extends PalletsTypedef<any, any, any, any, any>> = ExtractPlain<T["__const"]>;
 
+declare class RuntimeToken<D = unknown> {
+    private constructor();
+    protected _runtime(value: D): void;
+}
 declare class CompatibilityToken<D = unknown> {
     private constructor();
-    protected _phantom(value: D): void;
+    protected _compatibility(value: D): void;
 }
 interface CompatibilityFunctions<D> {
     /**
@@ -103,9 +107,24 @@ interface CompatibilityFunctions<D> {
     isCompatible(threshold: CompatibilityLevel, compatibilityToken: CompatibilityToken<D>): boolean;
 }
 
-interface ConstantEntry<D, T> extends CompatibilityFunctions<D> {
+type ConstantEntry<Unsafe, D, T> = Unsafe extends true ? {
+    /**
+     * Constants are simple key-value structures found in the runtime
+     * metadata.
+     *
+     * @returns Promise that will resolve in the value of the constant.
+     */
+    (): Promise<T>;
     /**
-     * Constants are simple key-value structures found in the runtime metadata.
+     * @param runtimeToken  Token from got with `await
+     *                      typedApi.runtimeToken`
+     * @returns Synchronously returns value of the constant.
+     */
+    (runtimeToken: RuntimeToken): T;
+} : {
+    /**
+     * Constants are simple key-value structures found in the runtime
+     * metadata.
      *
      * @returns Promise that will resolve in the value of the constant.
      */
@@ -116,7 +135,7 @@ interface ConstantEntry<D, T> extends CompatibilityFunctions<D> {
      * @returns Synchronously returns value of the constant.
      */
     (compatibilityToken: CompatibilityToken): T;
-}
+} & CompatibilityFunctions<D>;
 
 type EventPhase = {
     type: "ApplyExtrinsic";
@@ -141,7 +160,7 @@ type EvPull<T> = () => Promise<Array<{
     payload: T;
 }>>;
 type EvFilter<T> = (collection: SystemEvent["event"][]) => Array<T>;
-type EvClient<D, T> = {
+type EvClient<Unsafe, D, T> = {
     /**
      * Multicast and stateful Observable watching for new events (matching the
      * event kind chosen) in the latest known `finalized` block.
@@ -162,7 +181,7 @@ type EvClient<D, T> = {
      * @param collection  Array of `SystemEvent` to filter.
      */
     filter: EvFilter<T>;
-} & CompatibilityFunctions<D>;
+} & (Unsafe extends true ? {} : CompatibilityFunctions<D>);
 type SystemEvent = {
     phase: EventPhase;
     event: {
@@ -180,7 +199,7 @@ type CallOptions$1 = Partial<{
     signal: AbortSignal;
 }>;
 type WithCallOptions$1<Args extends Array<any>> = Args["length"] extends 0 ? [options?: CallOptions$1] : [...args: Args, options?: CallOptions$1];
-interface RuntimeCall<D, Args extends Array<any>, Payload> extends CompatibilityFunctions<D> {
+type RuntimeCall<Unsafe, D, Args extends Array<any>, Payload> = {
     /**
      * Get `Payload` (Promise-based) for the runtime call.
      *
@@ -189,7 +208,7 @@ interface RuntimeCall<D, Args extends Array<any>, Payload> extends Compatibility
      *              known finalized is the default) and an AbortSignal.
      */
     (...args: WithCallOptions$1<Args>): Promise<Payload>;
-}
+} & (Unsafe extends true ? {} : CompatibilityFunctions<D>);
 
 type CallOptions = Partial<{
     /**
@@ -211,7 +230,7 @@ type PossibleParents<A extends Array<any>> = A extends [...infer Left, any] ? Le
 type ArrayPossibleParents<A extends Array<any>, Count extends Array<any> = [], R = []> = A extends Array<infer T> & {
     length: infer L;
 } ? number extends L ? Array<T> : L extends Count["length"] ? R : ArrayPossibleParents<A, [...Count, T], R | Count> : never;
-type StorageEntryWithoutKeys<D, Payload> = {
+type StorageEntryWithoutKeys<Unsafe, D, Payload> = {
     /**
      * Get `Payload` (Promise-based) for the storage entry.
      *
@@ -226,8 +245,8 @@ type StorageEntryWithoutKeys<D, Payload> = {
      *                         changes, `best` or `finalized` (default)
      */
     watchValue: (bestOrFinalized?: "best" | "finalized") => Observable<Payload>;
-} & CompatibilityFunctions<D>;
-type StorageEntryWithKeys<D, Args extends Array<any>, Payload> = {
+} & (Unsafe extends true ? {} : CompatibilityFunctions<D>);
+type StorageEntryWithKeys<Unsafe, D, Args extends Array<any>, Payload> = {
     /**
      * Get `Payload` (Promise-based) for the storage entry with a specific set of
      * `Args`.
@@ -273,8 +292,8 @@ type StorageEntryWithKeys<D, Args extends Array<any>, Payload> = {
         keyArgs: Args;
         value: NonNullable<Payload>;
     }>>;
-} & CompatibilityFunctions<D>;
-type StorageEntry<D, Args extends Array<any>, Payload> = Args extends [] ? StorageEntryWithoutKeys<D, Payload> : StorageEntryWithKeys<D, Args, Payload>;
+} & (Unsafe extends true ? {} : CompatibilityFunctions<D>);
+type StorageEntry<Unsafe, D, Args extends Array<any>, Payload> = Args extends [] ? StorageEntryWithoutKeys<Unsafe, D, Payload> : StorageEntryWithKeys<Unsafe, D, Args, Payload>;
 
 type TxEvent = TxSigned | TxBroadcasted | TxBestBlocksState | TxFinalized;
 type TxBroadcastEvent = TxSigned | TxBroadcasted | TxBestBlocksState | TxFinalized;
@@ -410,6 +429,21 @@ interface TxCall {
      */
     (compatibilityToken: CompatibilityToken): Binary;
 }
+interface UnsafeTxCall {
+    /**
+     * SCALE-encoded callData of the transaction.
+     *
+     * @returns Promise resolving in the encoded data.
+     */
+    (): Promise<Binary>;
+    /**
+     * SCALE-encoded callData of the transaction.
+     *
+     * @param runtimeToken  Token from got with `await typedApi.runtimeToken`
+     * @returns Synchronously returns encoded data.
+     */
+    (runtimeToken: RuntimeToken): Binary;
+}
 type TxSignFn<Asset> = (from: PolkadotSigner, txOptions?: TxOptions<Asset>) => Promise<HexString>;
 type PaymentInfo = {
     weight: {
@@ -423,7 +457,7 @@ type PaymentInfo = {
     }>;
     partial_fee: bigint;
 };
-type Transaction<Arg extends {} | undefined, Pallet extends string, Name extends string, Asset> = {
+type InnerTransaction<Unsafe, Arg extends {} | undefined, Pallet extends string, Name extends string, Asset> = {
     /**
      * Pack the transaction, sends it to the signer, and return the signature
      * asynchronously. If the signer fails (or the user cancels the signature)
@@ -459,7 +493,7 @@ type Transaction<Arg extends {} | undefined, Pallet extends string, Name extends
     /**
      * SCALE-encoded callData of the transaction.
      */
-    getEncodedData: TxCall;
+    getEncodedData: Unsafe extends true ? UnsafeTxCall : TxCall;
     /**
      * Estimate fees against the latest known `finalizedBlock`
      *
@@ -487,43 +521,75 @@ type Transaction<Arg extends {} | undefined, Pallet extends string, Name extends
         }>;
     }>;
 };
-interface TxEntry<D, Arg extends {} | undefined, Pallet extends string, Name extends string, Asset> extends CompatibilityFunctions<D> {
+type Transaction<Arg extends {} | undefined, Pallet extends string, Name extends string, Asset> = InnerTransaction<false, Arg, Pallet, Name, Asset>;
+type UnsafeTransaction<Arg extends {} | undefined, Pallet extends string, Name extends string, Asset> = InnerTransaction<true, Arg, Pallet, Name, Asset>;
+type InnerTxEntry<Unsafe, D, Arg extends {} | undefined, Pallet extends string, Name extends string, Asset> = Unsafe extends true ? {
+    /**
+     * Synchronously create the transaction object ready to sign, submit,
+     * estimate fees, etc.
+     *
+     * @param args  All parameters required by the transaction.
+     * @returns Transaction object.
+     */
+    (...args: Arg extends undefined ? [] : [data: Arg]): UnsafeTransaction<Arg, Pallet, Name, Asset>;
+} : {
     /**
-     * Synchronously create the transaction object ready to sign, submit, estimate
-     * fees, etc.
+     * Synchronously create the transaction object ready to sign, submit,
+     * estimate fees, etc.
      *
      * @param args  All parameters required by the transaction.
      * @returns Transaction object.
      */
     (...args: Arg extends undefined ? [] : [data: Arg]): Transaction<Arg, Pallet, Name, Asset>;
-}
-interface TxFromBinary<Asset> {
+} & CompatibilityFunctions<D>;
+type TxEntry<D, Arg extends {} | undefined, Pallet extends string, Name extends string, Asset> = InnerTxEntry<false, D, Arg, Pallet, Name, Asset>;
+type UnsafeTxEntry<D, Arg extends {} | undefined, Pallet extends string, Name extends string, Asset> = InnerTxEntry<true, D, Arg, Pallet, Name, Asset>;
+type TxFromBinary<Unsafe, Asset> = Unsafe extends true ? {
     /**
-     * Asynchronously create the transaction object from a binary call data ready
-     * to sign, submit, estimate fees, etc.
+     * Asynchronously create the transaction object from a binary call data
+     * ready to sign, submit, estimate fees, etc.
      *
      * @param callData  SCALE-encoded call data.
      * @returns Transaction object.
      */
-    (callData: Binary): Promise<Transaction<any, any, any, Asset>>;
+    (callData: Binary): Promise<UnsafeTransaction<any, string, string, Asset>>;
+    /**
+     * Synchronously create the transaction object from a binary call data
+     * ready to sign, submit, estimate fees, etc.
+     *
+     * @param callData      SCALE-encoded call data.
+     * @param runtimeToken  Token from got with `await
+     *                      typedApi.runtimeToken`
+     * @returns Transaction object.
+     */
+    (callData: Binary, runtimeToken: RuntimeToken): UnsafeTransaction<any, string, string, Asset>;
+} : {
     /**
-     * Synchronously create the transaction object from a binary call data ready
-     * to sign, submit, estimate fees, etc.
+     * Asynchronously create the transaction object from a binary call data
+     * ready to sign, submit, estimate fees, etc.
+     *
+     * @param callData  SCALE-encoded call data.
+     * @returns Transaction object.
+     */
+    (callData: Binary): Promise<Transaction<any, string, string, Asset>>;
+    /**
+     * Synchronously create the transaction object from a binary call data
+     * ready to sign, submit, estimate fees, etc.
      *
      * @param callData            SCALE-encoded call data.
      * @param compatibilityToken  Token from got with `await
      *                            typedApi.compatibilityToken`
      * @returns Transaction object.
      */
-    (callData: Binary, compatibilityToken: CompatibilityToken): Transaction<any, any, any, Asset>;
-}
+    (callData: Binary, compatibilityToken: CompatibilityToken): Transaction<any, string, string, Asset>;
+};
 
 declare class InvalidTxError extends Error {
     error: any;
     constructor(e: any);
 }
 
-type StorageApi<D, A extends Record<string, Record<string, {
+type StorageApi<Unsafe, D, A extends Record<string, Record<string, {
     KeyArgs: Array<any>;
     Value: any;
     IsOptional: false | true;
@@ -533,38 +599,51 @@ type StorageApi<D, A extends Record<string, Record<string, {
             KeyArgs: Array<any>;
             Value: any;
             IsOptional: false | true;
-        } ? StorageEntry<D, A[K][KK]["KeyArgs"], A[K][KK]["IsOptional"] extends true ? A[K][KK]["Value"] | undefined : A[K][KK]["Value"]> : unknown;
+        } ? StorageEntry<Unsafe, D, A[K][KK]["KeyArgs"], A[K][KK]["IsOptional"] extends true ? A[K][KK]["Value"] | undefined : A[K][KK]["Value"]> : unknown;
     };
 };
-type RuntimeCallsApi<D, A extends Record<string, Record<string, RuntimeDescriptor<Array<any>, any>>>> = {
+type RuntimeCallsApi<Unsafe, D, A extends Record<string, Record<string, RuntimeDescriptor<Array<any>, any>>>> = {
     [K in keyof A]: {
-        [KK in keyof A[K]]: A[K][KK] extends RuntimeDescriptor<infer Args, infer Value> ? RuntimeCall<D, Args, Value> : unknown;
+        [KK in keyof A[K]]: A[K][KK] extends RuntimeDescriptor<infer Args, infer Value> ? RuntimeCall<Unsafe, D, Args, Value> : unknown;
     };
 };
-type TxApi<D, A extends Record<string, Record<string, any>>, Asset> = {
+type TxApi<Unsafe, D, A extends Record<string, Record<string, any>>, Asset> = {
     [K in keyof A]: {
-        [KK in keyof A[K]]: A[K][KK] extends {} | undefined ? TxEntry<D, A[K][KK], K & string, KK & string, Asset> : unknown;
+        [KK in keyof A[K]]: A[K][KK] extends {} | undefined ? InnerTxEntry<Unsafe, D, A[K][KK], K & string, KK & string, Asset> : unknown;
     };
 };
-type EvApi<D, A extends Record<string, Record<string, any>>> = {
+type EvApi<Unsafe, D, A extends Record<string, Record<string, any>>> = {
     [K in keyof A]: {
-        [KK in keyof A[K]]: EvClient<D, A[K][KK]>;
+        [KK in keyof A[K]]: EvClient<Unsafe, D, A[K][KK]>;
     };
 };
-type ConstApi<D, A extends Record<string, Record<string, any>>> = {
+type ConstApi<Unsafe, D, A extends Record<string, Record<string, any>>> = {
     [K in keyof A]: {
-        [KK in keyof A[K]]: ConstantEntry<D, A[K][KK]>;
+        [KK in keyof A[K]]: ConstantEntry<Unsafe, D, A[K][KK]>;
     };
 };
-type TypedApi<D extends ChainDefinition> = {
-    query: StorageApi<D, QueryFromPalletsDef<D["descriptors"]["pallets"]>>;
-    tx: TxApi<D, TxFromPalletsDef<D["descriptors"]["pallets"]>, D["asset"]["_type"]>;
-    txFromCallData: TxFromBinary<D["asset"]["_type"]>;
-    event: EvApi<D, EventsFromPalletsDef<D["descriptors"]["pallets"]>>;
-    apis: RuntimeCallsApi<D, D["descriptors"]["apis"]>;
-    constants: ConstApi<D, ConstFromPalletsDef<D["descriptors"]["pallets"]>>;
+type UnsafeEntry<T> = Record<string, Record<string, T>>;
+type AnyApi<Unsafe extends true | false, D> = D extends ChainDefinition ? {
+    query: StorageApi<Unsafe, D, QueryFromPalletsDef<D["descriptors"]["pallets"]>>;
+    tx: TxApi<Unsafe, D, TxFromPalletsDef<D["descriptors"]["pallets"]>, D["asset"]["_type"]>;
+    txFromCallData: TxFromBinary<Unsafe, D["asset"]["_type"]>;
+    event: EvApi<Unsafe, D, EventsFromPalletsDef<D["descriptors"]["pallets"]>>;
+    apis: RuntimeCallsApi<Unsafe, D, D["descriptors"]["apis"]>;
+    constants: ConstApi<Unsafe, D, ConstFromPalletsDef<D["descriptors"]["pallets"]>>;
+} : {
+    query: UnsafeEntry<StorageEntryWithKeys<true, D, any, any>>;
+    tx: UnsafeEntry<UnsafeTxEntry<D, any, string, string, any>>;
+    txFromCallData: TxFromBinary<Unsafe, any>;
+    event: UnsafeEntry<EvClient<true, D, any>>;
+    apis: UnsafeEntry<RuntimeCall<true, D, any, any>>;
+    constants: UnsafeEntry<ConstantEntry<true, D, any>>;
+};
+type TypedApi<D extends ChainDefinition> = AnyApi<false, D> & {
     compatibilityToken: Promise<CompatibilityToken<D>>;
 };
+type UnsafeApi<D> = AnyApi<true, D> & {
+    runtimeToken: Promise<RuntimeToken<D>>;
+};
 type TransactionValidityError<D extends ChainDefinition> = (D["descriptors"]["apis"]["TaggedTransactionQueue"]["validate_transaction"][1] & {
     success: false;
 })["value"];
@@ -656,6 +735,14 @@ interface PolkadotClient {
      *                     generated by `papi` CLI.
      */
     getTypedApi: <D extends ChainDefinition>(descriptors: D) => TypedApi<D>;
+    /**
+     * Returns an instance of a `UnsafeApi`.
+     *
+     * Note that this method is only meant for advanced users that really know
+     * what are they doing. This API does not provide any runtime compatibility
+     * checks protection and the consumer should implement them on their own.
+     */
+    getUnsafeApi: <D>() => UnsafeApi<D>;
     /**
      * This will `unfollow` the provider, disconnect and error every subscription.
      * After calling it nothing can be done with the client.
@@ -711,4 +798,4 @@ type TxCallData = {
  */
 declare function createClient(provider: JsonRpcProvider): PolkadotClient;
 
-export { type ApisTypedef, type ChainDefinition, CompatibilityToken, type ConstFromPalletsDef, type DescriptorEntry, type ErrorsFromPalletsDef, type EventPhase, type EventsFromPalletsDef, type FixedSizeArray, InvalidTxError, type PalletsTypedef, type PlainDescriptor, type PolkadotClient, type QueryFromPalletsDef, type RuntimeDescriptor, type StorageDescriptor, type Transaction, type TransactionValidityError, type TxBestBlocksState, type TxBroadcastEvent, type TxBroadcasted, type TxCall, type TxCallData, type TxDescriptor, type TxEntry, type TxEvent, type TxEventsPayload, type TxFinalized, type TxFinalizedPayload, type TxFromPalletsDef, type TxInBestBlocksFound, type TxInBestBlocksNotFound, type TxObservable, type TxOptions, type TxPromise, type TxSignFn, type TxSigned, type TypedApi, createClient };
+export { type ApisTypedef, type ChainDefinition, CompatibilityToken, type ConstFromPalletsDef, type DescriptorEntry, type ErrorsFromPalletsDef, type EventPhase, type EventsFromPalletsDef, type FixedSizeArray, InvalidTxError, type PalletsTypedef, type PlainDescriptor, type PolkadotClient, type QueryFromPalletsDef, type RuntimeDescriptor, RuntimeToken, type StorageDescriptor, type Transaction, type TransactionValidityError, type TxBestBlocksState, type TxBroadcastEvent, type TxBroadcasted, type TxCall, type TxCallData, type TxDescriptor, type TxEntry, type TxEvent, type TxEventsPayload, type TxFinalized, type TxFinalizedPayload, type TxFromPalletsDef, type TxInBestBlocksFound, type TxInBestBlocksNotFound, type TxObservable, type TxOptions, type TxPromise, type TxSignFn, type TxSigned, type TypedApi, type UnsafeTransaction, type UnsafeTxCall, type UnsafeTxEntry, createClient };

package/dist/index.js

@@ -9,15 +9,23 @@ var utils = require('@polkadot-api/utils');
 var signer = require('@polkadot-api/signer');
 var metadataBuilders = require('@polkadot-api/metadata-builders');
 
+class RuntimeToken {
+  constructor() {
+  }
+  // @ts-ignore
+  _runtime(value) {
+  }
+}
 class CompatibilityToken {
   constructor() {
   }
   // @ts-ignore
-  _phantom(value) {
+  _compatibility(value) {
   }
 }
 const compatibilityTokenApi = /* @__PURE__ */ new WeakMap();
-const getCompatibilityApi = (token) => compatibilityTokenApi.get(token);
+const runtimeTokenApi = /* @__PURE__ */ new WeakMap();
+const getCompatibilityApi = (token) => token instanceof RuntimeToken ? runtimeTokenApi.get(token) : compatibilityTokenApi.get(token);
 var OpType = /* @__PURE__ */ ((OpType2) => {
   OpType2["Storage"] = "storage";
   OpType2["Tx"] = "tx";
@@ -55,6 +63,22 @@ const createCompatibilityToken = (chainDefinition, chainHead) => {
   });
   return promise;
 };
+const createRuntimeToken = (chainHead) => {
+  const awaitedRuntime = new Promise(async (resolve) => {
+    const loadedRuntime$ = chainHead.runtime$.pipe(rxjs.filter((v) => v != null));
+    let latest = await rxjs.firstValueFrom(loadedRuntime$);
+    loadedRuntime$.subscribe((v) => latest = v);
+    resolve(() => latest);
+  });
+  const promise = awaitedRuntime.then((runtime) => {
+    const token = new RuntimeToken();
+    runtimeTokenApi.set(token, {
+      runtime
+    });
+    return token;
+  });
+  return promise;
+};
 const metadataCache = /* @__PURE__ */ new WeakMap();
 const getMetadataCache = (ctx) => {
   if (!metadataCache.has(ctx.metadataRaw)) {
@@ -73,6 +97,12 @@ const compatibilityHelper = (descriptors, getDescriptorEntryPoint, getRuntimeEnt
     return (_a = cache.typeNodes)[id] || (_a[id] = metadataCompatibility.mapLookupToTypedef(cache.lookup(id)));
   };
   function getCompatibilityLevels(descriptors2, ctx) {
+    if (descriptors2 instanceof RuntimeToken) {
+      return {
+        args: metadataCompatibility.CompatibilityLevel.Identical,
+        values: metadataCompatibility.CompatibilityLevel.Identical
+      };
+    }
     const compatibilityApi = compatibilityTokenApi.get(descriptors2);
     ctx || (ctx = compatibilityApi.runtime());
     const descriptorEntryPoint = getDescriptorEntryPoint(compatibilityApi);
@@ -102,6 +132,7 @@ const compatibilityHelper = (descriptors, getDescriptorEntryPoint, getRuntimeEnt
     waitDescriptors()
   ]).pipe(rxjs.map(([[x, ctx], descriptors2]) => [x, descriptors2, ctx]));
   const argsAreCompatible = (descriptors2, ctx, args) => {
+    if (descriptors2 instanceof RuntimeToken) return true;
     const levels = getCompatibilityLevels(descriptors2, ctx);
     if (levels.args === metadataCompatibility.CompatibilityLevel.Incompatible) return false;
     if (levels.args > metadataCompatibility.CompatibilityLevel.Partial) return true;
@@ -114,6 +145,7 @@ const compatibilityHelper = (descriptors, getDescriptorEntryPoint, getRuntimeEnt
     );
   };
   const valuesAreCompatible = (descriptors2, ctx, values) => {
+    if (descriptors2 instanceof RuntimeToken) return true;
     const level = getCompatibilityLevels(descriptors2, ctx).values;
     if (level === metadataCompatibility.CompatibilityLevel.Incompatible) return false;
     if (level > metadataCompatibility.CompatibilityLevel.Partial) return true;
@@ -140,7 +172,7 @@ const compatibilityHelper = (descriptors, getDescriptorEntryPoint, getRuntimeEnt
 const minCompatLevel = (levels) => Math.min(levels.args, levels.values);
 const withOptionalToken = (compatibilityToken, fn) => (...args) => {
   const lastElement = args.at(-1);
-  if (lastElement instanceof CompatibilityToken) {
+  if (lastElement instanceof CompatibilityToken || lastElement instanceof RuntimeToken) {
     return fn(...args);
   }
   return compatibilityToken.then((token) => fn(...args, token));
@@ -167,11 +199,11 @@ const createConstantEntry = (palletName, name, {
     cachedResults.set(ctx, result);
     return result;
   };
-  const fn = (compatibilityToken) => {
-    if (compatibilityToken) {
-      const ctx = getCompatibilityApi(compatibilityToken).runtime();
+  const fn = (token) => {
+    if (token) {
+      const ctx = getCompatibilityApi(token).runtime();
       const value = getValueWithContext(ctx);
-      if (!valuesAreCompatible(compatibilityToken, ctx, value))
+      if (!valuesAreCompatible(token, ctx, value))
         throw new Error(
           `Incompatible runtime entry Constant(${palletName}.${name})`
         );
@@ -980,10 +1012,10 @@ const createTxEntry = (pallet, name, chainHead, broadcast, {
     const getCallData$ = (arg2, options = {}) => compatibleRuntime$(chainHead, null).pipe(
       rxjs.map(([runtime]) => getCallDataWithContext(runtime, arg2, options))
     );
-    const getEncodedData = (compatibilityToken) => {
-      if (!compatibilityToken)
+    const getEncodedData = (token) => {
+      if (!token)
         return rxjs.firstValueFrom(getCallData$(arg).pipe(rxjs.map((x) => x.callData)));
-      return getCallDataWithContext(compatibilityToken, arg).callData;
+      return getCallDataWithContext(token, arg).callData;
     };
     const sign$ = (from, { ..._options }, atBlock) => getCallData$(arg, _options).pipe(
       rxjs.mergeMap(
@@ -1058,7 +1090,7 @@ const createTxEntry = (pallet, name, chainHead, broadcast, {
   });
 };
 
-const createTypedApi = (compatibilityToken, chainHead, broadcast$) => {
+const createApi = (compatibilityToken, chainHead, broadcast$) => {
   const target = {};
   const createProxy = (propCall) => new Proxy(target, {
     get(_, prop) {
@@ -1182,8 +1214,7 @@ const createTypedApi = (compatibilityToken, chainHead, broadcast$) => {
     tx,
     event,
     apis,
-    constants,
-    compatibilityToken
+    constants
   };
 };
 function createClient(provider) {
@@ -1192,12 +1223,14 @@ function createClient(provider) {
   const chainHead = client.chainHead$();
   const { getChainSpecData } = rawClient;
   const _request = rawClient.request;
+  let runtimeToken;
   const compatibilityToken = /* @__PURE__ */ new WeakMap();
   const getChainToken = (chainDefinition) => {
     const result = compatibilityToken.get(chainDefinition) || createCompatibilityToken(chainDefinition, chainHead);
     compatibilityToken.set(chainDefinition, result);
     return result;
   };
+  const getRuntimeToken = () => runtimeToken ?? (runtimeToken = createRuntimeToken(chainHead));
   const { broadcastTx$ } = client;
   return {
     getChainSpecData,
@@ -1210,7 +1243,19 @@ function createClient(provider) {
     getBlockHeader: (hash) => rxjs.firstValueFrom(chainHead.header$(hash ?? null)),
     submit: (...args) => submit(chainHead, broadcastTx$, ...args),
     submitAndWatch: (...args) => submit$(chainHead, broadcastTx$, ...args),
-    getTypedApi: (chainDefinition) => createTypedApi(getChainToken(chainDefinition), chainHead, broadcastTx$),
+    getTypedApi: (chainDefinition) => {
+      const token = getChainToken(chainDefinition);
+      return Object.assign(
+        createApi(token, chainHead, broadcastTx$),
+        { compatibilityToken: token }
+      );
+    },
+    getUnsafeApi: () => {
+      const token = getRuntimeToken();
+      return Object.assign(createApi(token, chainHead, broadcastTx$), {
+        runtimeToken: token
+      });
+    },
     destroy: () => {
       chainHead.unfollow();
       client.destroy();