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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Josep M Sobrepere
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @polkadot-api/client

package/bin/cli.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+// src/reexports/cli.ts
+import { add, generate, getCli, remove, update } from "@polkadot-api/cli";
+getCli({
+  add,
+  generate,
+  remove,
+  update
+}).parse();
+//# sourceMappingURL=cli.mjs.map

package/dist/index.d.mts

@@ -0,0 +1,269 @@
+import { HexString, Enum, Binary, Descriptors, QueryFromDescriptors, TxFromDescriptors, EventsFromDescriptors, ConstFromDescriptors, BlockHeader, RuntimeDescriptor } from '@polkadot-api/substrate-bindings';
+export { AccountId, AssetDescriptor, Binary, Codec, ConstFromDescriptors, Enum, ErrorsFromDescriptors, EventsFromDescriptors, FixedSizeBinary, GetEnum, HexString, PlainDescriptor, QueryFromDescriptors, ResultPayload, RuntimeDescriptor, SS58String, StorageDescriptor, TxDescriptor, TxFromDescriptors, _Enum } from '@polkadot-api/substrate-bindings';
+import { Observable } from 'rxjs';
+import { BlockInfo, SystemEvent as SystemEvent$1 } from '@polkadot-api/observable-client';
+import { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
+export { PolkadotSigner } from '@polkadot-api/polkadot-signer';
+
+declare class Runtime {
+    protected _ctx: unknown;
+    protected _checksums: string[];
+    private constructor();
+}
+type RuntimeApi = Observable<Runtime> & {
+    latest: () => Promise<Runtime>;
+};
+interface IsCompatible {
+    (): Promise<boolean>;
+    (runtime: Runtime): boolean;
+}
+
+type EventPhase = {
+    type: "ApplyExtrinsic";
+    value: number;
+} | {
+    type: "Finalization";
+} | {
+    type: "Initialization";
+};
+type EvWatch<T> = (filter?: (value: T) => boolean) => Observable<{
+    meta: {
+        block: BlockInfo;
+        phase: EventPhase;
+    };
+    payload: T;
+}>;
+type EvPull<T> = () => Promise<Array<{
+    meta: {
+        block: BlockInfo;
+        phase: EventPhase;
+    };
+    payload: T;
+}>>;
+type EvFilter<T> = (collection: SystemEvent["event"][]) => Array<T>;
+type EvClient<T> = {
+    watch: EvWatch<T>;
+    pull: EvPull<T>;
+    filter: EvFilter<T>;
+    isCompatible: IsCompatible;
+};
+type SystemEvent = {
+    phase: EventPhase;
+    event: {
+        type: string;
+        value: {
+            type: string;
+            value: any;
+        };
+    };
+    topics: Array<any>;
+};
+
+type CallOptions$1 = Partial<{
+    at: string;
+    signal: AbortSignal;
+}>;
+type WithCallOptions$1<Args extends Array<any>> = [
+    ...args: Args,
+    options?: CallOptions$1
+];
+type PossibleParents<A extends Array<any>> = A extends [...infer Left, any] ? Left | PossibleParents<Left> : [];
+type StorageEntryWithoutKeys<Payload> = {
+    isCompatible: IsCompatible;
+    getValue: (options?: CallOptions$1) => Promise<Payload>;
+    watchValue: (bestOrFinalized?: "best" | "finalized") => Observable<Payload>;
+};
+type StorageEntryWithKeys<Args extends Array<any>, Payload> = {
+    isCompatible: IsCompatible;
+    getValue: (...args: [...WithCallOptions$1<Args>]) => Promise<Payload>;
+    watchValue: (...args: [...Args, bestOrFinalized?: "best" | "finalized"]) => Observable<Payload>;
+    getValues: (keys: Array<[...Args]>, options?: CallOptions$1) => Promise<Array<Payload>>;
+    getEntries: (...args: WithCallOptions$1<PossibleParents<Args>>) => Promise<Array<{
+        keyArgs: Args;
+        value: NonNullable<Payload>;
+    }>>;
+};
+type StorageEntry<Args extends Array<any>, Payload> = Args extends [] ? StorageEntryWithoutKeys<Payload> : StorageEntryWithKeys<Args, Payload>;
+
+interface PolkadotSigner {
+    publicKey: Uint8Array;
+    sign: (callData: Uint8Array, signedExtensions: Record<string, {
+        identifier: string;
+        value: Uint8Array;
+        additionalSigned: Uint8Array;
+    }>, metadata: Uint8Array, atBlockNumber: number, hasher?: (data: Uint8Array) => Uint8Array) => Promise<Uint8Array>;
+}
+
+type TxBroadcastEvent = {
+    type: "broadcasted";
+} | {
+    type: "bestChainBlockIncluded";
+    block: {
+        hash: string;
+        index: number;
+    };
+} | ({
+    type: "finalized";
+} & TxFinalizedPayload);
+type TxEvent = TxBroadcastEvent | {
+    type: "signed";
+    tx: HexString;
+};
+type TxFinalizedPayload = {
+    ok: boolean;
+    events: Array<SystemEvent$1["event"]>;
+    block: {
+        hash: string;
+        index: number;
+    };
+};
+type TxFunction<Asset> = (from: PolkadotSigner, hintedSignExtensions?: Partial<void extends Asset ? {
+    tip: bigint;
+    mortal: {
+        mortal: false;
+    } | {
+        mortal: true;
+        period: number;
+    };
+} : {
+    tip: bigint;
+    mortal: {
+        mortal: false;
+    } | {
+        mortal: true;
+        period: number;
+    };
+    asset: Asset;
+}>) => Promise<TxFinalizedPayload>;
+type TxObservable<Asset> = (from: PolkadotSigner, hintedSignExtensions?: Partial<void extends Asset ? {
+    tip: bigint;
+    mortal: {
+        mortal: false;
+    } | {
+        mortal: true;
+        period: number;
+    };
+} : {
+    tip: bigint;
+    mortal: {
+        mortal: false;
+    } | {
+        mortal: true;
+        period: number;
+    };
+    asset: Asset;
+}>) => Observable<TxEvent>;
+interface TxCall {
+    (): Promise<Binary>;
+    (runtime: Runtime): Binary;
+}
+type TxSigned<Asset> = (from: PolkadotSigner, hintedSignExtensions?: Partial<void extends Asset ? {
+    tip: bigint;
+    mortal: {
+        mortal: false;
+    } | {
+        mortal: true;
+        period: number;
+    };
+} : {
+    tip: bigint;
+    mortal: {
+        mortal: false;
+    } | {
+        mortal: true;
+        period: number;
+    };
+    asset: Asset;
+}>) => Promise<string>;
+type Transaction<Arg extends {} | undefined, Pallet extends string, Name extends string, Asset> = {
+    sign: TxSigned<Asset>;
+    signSubmitAndWatch: TxObservable<Asset>;
+    signAndSubmit: TxFunction<Asset>;
+    getEncodedData: TxCall;
+    decodedCall: Enum<{
+        type: Pallet;
+        value: Enum<{
+            type: Name;
+            value: Arg;
+        }>;
+    }>;
+};
+interface TxEntry<Arg extends {} | undefined, Pallet extends string, Name extends string, Asset> {
+    (...args: Arg extends undefined ? [] : [data: Arg]): Transaction<Arg, Pallet, Name, Asset>;
+    isCompatible: IsCompatible;
+}
+
+interface ConstantEntry<T> {
+    (): Promise<T>;
+    (runtime: Runtime): T;
+    isCompatible: IsCompatible;
+}
+
+type CallOptions = Partial<{
+    at: string;
+    signal: AbortSignal;
+}>;
+type WithCallOptions<Args extends Array<any>> = Args["length"] extends 0 ? [options?: CallOptions] : [...args: Args, options?: CallOptions];
+interface RuntimeCall<Args extends Array<any>, Payload> {
+    (...args: WithCallOptions<Args>): Promise<Payload>;
+    isCompatible: IsCompatible;
+}
+
+type StorageApi<A extends Record<string, Record<string, {
+    KeyArgs: Array<any>;
+    Value: any;
+    IsOptional: false | true;
+} | unknown>>> = {
+    [K in keyof A]: {
+        [KK in keyof A[K]]: A[K][KK] extends {
+            KeyArgs: Array<any>;
+            Value: any;
+            IsOptional: false | true;
+        } ? StorageEntry<A[K][KK]["KeyArgs"], A[K][KK]["IsOptional"] extends true ? A[K][KK]["Value"] | undefined : A[K][KK]["Value"]> : unknown;
+    };
+};
+type RuntimeCallsApi<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<Args, Value> : unknown;
+    };
+};
+type TxApi<A extends Record<string, Record<string, any>>, Asset> = {
+    [K in keyof A]: {
+        [KK in keyof A[K]]: A[K][KK] extends {} | undefined ? TxEntry<A[K][KK], K & string, KK & string, Asset> : unknown;
+    };
+};
+type EvApi<A extends Record<string, Record<string, any>>> = {
+    [K in keyof A]: {
+        [KK in keyof A[K]]: EvClient<A[K][KK]>;
+    };
+};
+type ConstApi<A extends Record<string, Record<string, any>>> = {
+    [K in keyof A]: {
+        [KK in keyof A[K]]: ConstantEntry<A[K][KK]>;
+    };
+};
+type TypedApi<D extends Descriptors> = {
+    query: StorageApi<QueryFromDescriptors<D>>;
+    tx: TxApi<TxFromDescriptors<D>, D["asset"]["_type"]>;
+    event: EvApi<EventsFromDescriptors<D>>;
+    apis: RuntimeCallsApi<D["apis"]>;
+    constants: ConstApi<ConstFromDescriptors<D>>;
+    runtime: RuntimeApi;
+};
+interface PolkadotClient {
+    finalized$: Observable<BlockInfo>;
+    bestBlocks$: Observable<BlockInfo[]>;
+    getBlockHeader: (hash?: string) => Promise<BlockHeader>;
+    getBlockBody: (hash: string) => Observable<HexString[]>;
+    getTypedApi: <D extends Descriptors>(descriptors: D) => TypedApi<D>;
+    destroy: () => void;
+    submit: (transaction: HexString) => Promise<TxFinalizedPayload>;
+    submitAndWatch: (transaction: HexString) => Observable<TxBroadcastEvent>;
+}
+type FixedSizeArray<L extends number, T> = Array<T> & {
+    length: L;
+};
+
+declare function createClient(provider: JsonRpcProvider): PolkadotClient;
+
+export { type EventPhase, type FixedSizeArray, type PolkadotClient, type TxBroadcastEvent, type TxEvent, type TxFinalizedPayload, type TypedApi, createClient };

package/dist/index.d.ts

@@ -0,0 +1,269 @@
+import { HexString, Enum, Binary, Descriptors, QueryFromDescriptors, TxFromDescriptors, EventsFromDescriptors, ConstFromDescriptors, BlockHeader, RuntimeDescriptor } from '@polkadot-api/substrate-bindings';
+export { AccountId, AssetDescriptor, Binary, Codec, ConstFromDescriptors, Enum, ErrorsFromDescriptors, EventsFromDescriptors, FixedSizeBinary, GetEnum, HexString, PlainDescriptor, QueryFromDescriptors, ResultPayload, RuntimeDescriptor, SS58String, StorageDescriptor, TxDescriptor, TxFromDescriptors, _Enum } from '@polkadot-api/substrate-bindings';
+import { Observable } from 'rxjs';
+import { BlockInfo, SystemEvent as SystemEvent$1 } from '@polkadot-api/observable-client';
+import { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
+export { PolkadotSigner } from '@polkadot-api/polkadot-signer';
+
+declare class Runtime {
+    protected _ctx: unknown;
+    protected _checksums: string[];
+    private constructor();
+}
+type RuntimeApi = Observable<Runtime> & {
+    latest: () => Promise<Runtime>;
+};
+interface IsCompatible {
+    (): Promise<boolean>;
+    (runtime: Runtime): boolean;
+}
+
+type EventPhase = {
+    type: "ApplyExtrinsic";
+    value: number;
+} | {
+    type: "Finalization";
+} | {
+    type: "Initialization";
+};
+type EvWatch<T> = (filter?: (value: T) => boolean) => Observable<{
+    meta: {
+        block: BlockInfo;
+        phase: EventPhase;
+    };
+    payload: T;
+}>;
+type EvPull<T> = () => Promise<Array<{
+    meta: {
+        block: BlockInfo;
+        phase: EventPhase;
+    };
+    payload: T;
+}>>;
+type EvFilter<T> = (collection: SystemEvent["event"][]) => Array<T>;
+type EvClient<T> = {
+    watch: EvWatch<T>;
+    pull: EvPull<T>;
+    filter: EvFilter<T>;
+    isCompatible: IsCompatible;
+};
+type SystemEvent = {
+    phase: EventPhase;
+    event: {
+        type: string;
+        value: {
+            type: string;
+            value: any;
+        };
+    };
+    topics: Array<any>;
+};
+
+type CallOptions$1 = Partial<{
+    at: string;
+    signal: AbortSignal;
+}>;
+type WithCallOptions$1<Args extends Array<any>> = [
+    ...args: Args,
+    options?: CallOptions$1
+];
+type PossibleParents<A extends Array<any>> = A extends [...infer Left, any] ? Left | PossibleParents<Left> : [];
+type StorageEntryWithoutKeys<Payload> = {
+    isCompatible: IsCompatible;
+    getValue: (options?: CallOptions$1) => Promise<Payload>;
+    watchValue: (bestOrFinalized?: "best" | "finalized") => Observable<Payload>;
+};
+type StorageEntryWithKeys<Args extends Array<any>, Payload> = {
+    isCompatible: IsCompatible;
+    getValue: (...args: [...WithCallOptions$1<Args>]) => Promise<Payload>;
+    watchValue: (...args: [...Args, bestOrFinalized?: "best" | "finalized"]) => Observable<Payload>;
+    getValues: (keys: Array<[...Args]>, options?: CallOptions$1) => Promise<Array<Payload>>;
+    getEntries: (...args: WithCallOptions$1<PossibleParents<Args>>) => Promise<Array<{
+        keyArgs: Args;
+        value: NonNullable<Payload>;
+    }>>;
+};
+type StorageEntry<Args extends Array<any>, Payload> = Args extends [] ? StorageEntryWithoutKeys<Payload> : StorageEntryWithKeys<Args, Payload>;
+
+interface PolkadotSigner {
+    publicKey: Uint8Array;
+    sign: (callData: Uint8Array, signedExtensions: Record<string, {
+        identifier: string;
+        value: Uint8Array;
+        additionalSigned: Uint8Array;
+    }>, metadata: Uint8Array, atBlockNumber: number, hasher?: (data: Uint8Array) => Uint8Array) => Promise<Uint8Array>;
+}
+
+type TxBroadcastEvent = {
+    type: "broadcasted";
+} | {
+    type: "bestChainBlockIncluded";
+    block: {
+        hash: string;
+        index: number;
+    };
+} | ({
+    type: "finalized";
+} & TxFinalizedPayload);
+type TxEvent = TxBroadcastEvent | {
+    type: "signed";
+    tx: HexString;
+};
+type TxFinalizedPayload = {
+    ok: boolean;
+    events: Array<SystemEvent$1["event"]>;
+    block: {
+        hash: string;
+        index: number;
+    };
+};
+type TxFunction<Asset> = (from: PolkadotSigner, hintedSignExtensions?: Partial<void extends Asset ? {
+    tip: bigint;
+    mortal: {
+        mortal: false;
+    } | {
+        mortal: true;
+        period: number;
+    };
+} : {
+    tip: bigint;
+    mortal: {
+        mortal: false;
+    } | {
+        mortal: true;
+        period: number;
+    };
+    asset: Asset;
+}>) => Promise<TxFinalizedPayload>;
+type TxObservable<Asset> = (from: PolkadotSigner, hintedSignExtensions?: Partial<void extends Asset ? {
+    tip: bigint;
+    mortal: {
+        mortal: false;
+    } | {
+        mortal: true;
+        period: number;
+    };
+} : {
+    tip: bigint;
+    mortal: {
+        mortal: false;
+    } | {
+        mortal: true;
+        period: number;
+    };
+    asset: Asset;
+}>) => Observable<TxEvent>;
+interface TxCall {
+    (): Promise<Binary>;
+    (runtime: Runtime): Binary;
+}
+type TxSigned<Asset> = (from: PolkadotSigner, hintedSignExtensions?: Partial<void extends Asset ? {
+    tip: bigint;
+    mortal: {
+        mortal: false;
+    } | {
+        mortal: true;
+        period: number;
+    };
+} : {
+    tip: bigint;
+    mortal: {
+        mortal: false;
+    } | {
+        mortal: true;
+        period: number;
+    };
+    asset: Asset;
+}>) => Promise<string>;
+type Transaction<Arg extends {} | undefined, Pallet extends string, Name extends string, Asset> = {
+    sign: TxSigned<Asset>;
+    signSubmitAndWatch: TxObservable<Asset>;
+    signAndSubmit: TxFunction<Asset>;
+    getEncodedData: TxCall;
+    decodedCall: Enum<{
+        type: Pallet;
+        value: Enum<{
+            type: Name;
+            value: Arg;
+        }>;
+    }>;
+};
+interface TxEntry<Arg extends {} | undefined, Pallet extends string, Name extends string, Asset> {
+    (...args: Arg extends undefined ? [] : [data: Arg]): Transaction<Arg, Pallet, Name, Asset>;
+    isCompatible: IsCompatible;
+}
+
+interface ConstantEntry<T> {
+    (): Promise<T>;
+    (runtime: Runtime): T;
+    isCompatible: IsCompatible;
+}
+
+type CallOptions = Partial<{
+    at: string;
+    signal: AbortSignal;
+}>;
+type WithCallOptions<Args extends Array<any>> = Args["length"] extends 0 ? [options?: CallOptions] : [...args: Args, options?: CallOptions];
+interface RuntimeCall<Args extends Array<any>, Payload> {
+    (...args: WithCallOptions<Args>): Promise<Payload>;
+    isCompatible: IsCompatible;
+}
+
+type StorageApi<A extends Record<string, Record<string, {
+    KeyArgs: Array<any>;
+    Value: any;
+    IsOptional: false | true;
+} | unknown>>> = {
+    [K in keyof A]: {
+        [KK in keyof A[K]]: A[K][KK] extends {
+            KeyArgs: Array<any>;
+            Value: any;
+            IsOptional: false | true;
+        } ? StorageEntry<A[K][KK]["KeyArgs"], A[K][KK]["IsOptional"] extends true ? A[K][KK]["Value"] | undefined : A[K][KK]["Value"]> : unknown;
+    };
+};
+type RuntimeCallsApi<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<Args, Value> : unknown;
+    };
+};
+type TxApi<A extends Record<string, Record<string, any>>, Asset> = {
+    [K in keyof A]: {
+        [KK in keyof A[K]]: A[K][KK] extends {} | undefined ? TxEntry<A[K][KK], K & string, KK & string, Asset> : unknown;
+    };
+};
+type EvApi<A extends Record<string, Record<string, any>>> = {
+    [K in keyof A]: {
+        [KK in keyof A[K]]: EvClient<A[K][KK]>;
+    };
+};
+type ConstApi<A extends Record<string, Record<string, any>>> = {
+    [K in keyof A]: {
+        [KK in keyof A[K]]: ConstantEntry<A[K][KK]>;
+    };
+};
+type TypedApi<D extends Descriptors> = {
+    query: StorageApi<QueryFromDescriptors<D>>;
+    tx: TxApi<TxFromDescriptors<D>, D["asset"]["_type"]>;
+    event: EvApi<EventsFromDescriptors<D>>;
+    apis: RuntimeCallsApi<D["apis"]>;
+    constants: ConstApi<ConstFromDescriptors<D>>;
+    runtime: RuntimeApi;
+};
+interface PolkadotClient {
+    finalized$: Observable<BlockInfo>;
+    bestBlocks$: Observable<BlockInfo[]>;
+    getBlockHeader: (hash?: string) => Promise<BlockHeader>;
+    getBlockBody: (hash: string) => Observable<HexString[]>;
+    getTypedApi: <D extends Descriptors>(descriptors: D) => TypedApi<D>;
+    destroy: () => void;
+    submit: (transaction: HexString) => Promise<TxFinalizedPayload>;
+    submitAndWatch: (transaction: HexString) => Observable<TxBroadcastEvent>;
+}
+type FixedSizeArray<L extends number, T> = Array<T> & {
+    length: L;
+};
+
+declare function createClient(provider: JsonRpcProvider): PolkadotClient;
+
+export { type EventPhase, type FixedSizeArray, type PolkadotClient, type TxBroadcastEvent, type TxEvent, type TxFinalizedPayload, type TypedApi, createClient };