@dedot/api 0.0.1-alpha.32

package/extrinsic/submittable/SubmittableResult.js

@@ -0,0 +1,29 @@
+export class SubmittableResult {
+    status;
+    events;
+    dispatchInfo;
+    dispatchError;
+    txHash;
+    txIndex;
+    constructor({ events, status, txHash, txIndex }) {
+        this.events = events || [];
+        this.status = status;
+        this.txHash = txHash;
+        this.txIndex = txIndex;
+        [this.dispatchInfo, this.dispatchError] = this._extractDispatchInfo();
+    }
+    _extractDispatchInfo() {
+        for (const { event } of this.events) {
+            const { pallet, palletEvent } = event;
+            if (pallet === 'System' && palletEvent.name === 'ExtrinsicFailed') {
+                const { dispatchInfo, dispatchError } = palletEvent.data;
+                return [dispatchInfo, dispatchError];
+            }
+            else if (pallet === 'System' && palletEvent.name === 'ExtrinsicSuccess') {
+                const { dispatchInfo } = palletEvent.data;
+                return [dispatchInfo, undefined];
+            }
+        }
+        return [undefined, undefined];
+    }
+}

package/extrinsic/submittable/errors.d.ts

@@ -0,0 +1,11 @@
+import type { Result } from '@dedot/codecs';
+import { DedotError } from '@dedot/utils';
+import type { SpRuntimeTransactionValidityTransactionValidityError, SpRuntimeTransactionValidityValidTransaction } from '../../chaintypes/index.js';
+/**
+ * This throws out if the extrinsic is invalid
+ * after verifying via `call.taggedTransactionQueue.validateTransaction`
+ */
+export declare class InvalidTxError extends DedotError {
+    data: Result<SpRuntimeTransactionValidityValidTransaction, SpRuntimeTransactionValidityTransactionValidityError>;
+    constructor(message: string, data: Result<SpRuntimeTransactionValidityValidTransaction, SpRuntimeTransactionValidityTransactionValidityError>);
+}

package/extrinsic/submittable/errors.js

@@ -0,0 +1,12 @@
+import { DedotError } from '@dedot/utils';
+/**
+ * This throws out if the extrinsic is invalid
+ * after verifying via `call.taggedTransactionQueue.validateTransaction`
+ */
+export class InvalidTxError extends DedotError {
+    data;
+    constructor(message, data) {
+        super(message);
+        this.data = data;
+    }
+}

package/extrinsic/submittable/fakeSigner.d.ts

@@ -0,0 +1,2 @@
+import type { Signer } from '@polkadot/types/types';
+export declare const fakeSigner: Signer;

package/extrinsic/submittable/fakeSigner.js

@@ -0,0 +1,10 @@
+import { u8aToHex } from '@dedot/utils';
+const FAKE_SIGNATURE = new Uint8Array(64 * 8).fill(0);
+export const fakeSigner = {
+    signPayload: async () => {
+        return {
+            id: Date.now(),
+            signature: u8aToHex(FAKE_SIGNATURE),
+        };
+    },
+};

package/extrinsic/submittable/index.d.ts

@@ -0,0 +1,4 @@
+export * from './errors.js';
+export * from './SubmittableResult.js';
+export * from './SubmittableExtrinsic.js';
+export * from './SubmittableExtrinsicV2.js';

package/extrinsic/submittable/index.js

@@ -0,0 +1,4 @@
+export * from './errors.js';
+export * from './SubmittableResult.js';
+export * from './SubmittableExtrinsic.js';
+export * from './SubmittableExtrinsicV2.js';

package/extrinsic/submittable/utils.d.ts

@@ -0,0 +1,10 @@
+import { IKeyringPair } from '@polkadot/types/types';
+import type { AddressOrPair } from '@dedot/types';
+import { HexString } from '@dedot/utils';
+export declare function isKeyringPair(account: AddressOrPair): account is IKeyringPair;
+/**
+ * Sign a raw message
+ * @param signerPair
+ * @param raw
+ */
+export declare function signRaw(signerPair: IKeyringPair, raw: HexString): Uint8Array;

package/extrinsic/submittable/utils.js

@@ -0,0 +1,15 @@
+import { blake2AsU8a, hexToU8a, isFunction } from '@dedot/utils';
+export function isKeyringPair(account) {
+    return isFunction(account.sign);
+}
+/**
+ * Sign a raw message
+ * @param signerPair
+ * @param raw
+ */
+export function signRaw(signerPair, raw) {
+    const u8a = hexToU8a(raw);
+    // Ref: https://github.com/paritytech/polkadot-sdk/blob/943697fa693a4da6ef481ef93df522accb7d0583/substrate/primitives/runtime/src/generic/unchecked_extrinsic.rs#L234-L238
+    const toSignRaw = u8a.length > 256 ? blake2AsU8a(u8a, 256) : u8a;
+    return signerPair.sign(toSignRaw, { withType: true });
+}

package/index.d.ts

@@ -0,0 +1,6 @@
+export type * from './types.js';
+export * from './storage/index.js';
+export * from './extrinsic/index.js';
+export * from './executor/index.js';
+export * from './json-rpc/index.js';
+export * from './client/index.js';

package/index.js

@@ -0,0 +1,5 @@
+export * from './storage/index.js';
+export * from './extrinsic/index.js';
+export * from './executor/index.js';
+export * from './json-rpc/index.js';
+export * from './client/index.js';

package/json-rpc/JsonRpcClient.d.ts

@@ -0,0 +1,50 @@
+import type { ConnectionStatus, JsonRpcProvider, ProviderEvent } from '@dedot/providers';
+import type { GenericSubstrateApi, RpcVersion } from '@dedot/types';
+import { EventEmitter } from '@dedot/utils';
+import type { SubstrateApi } from '../chaintypes/index.js';
+import type { IJsonRpcClient, JsonRpcClientOptions } from '../types.js';
+export declare const isJsonRpcProvider: (provider: any) => provider is JsonRpcProvider;
+export declare class JsonRpcClient<ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion], Events extends string = ProviderEvent> extends EventEmitter<Events> implements IJsonRpcClient<ChainApi, Events> {
+    #private;
+    constructor(options: JsonRpcClientOptions | JsonRpcProvider);
+    /**
+     * Factory method to create a new JsonRpcClient instance
+     *
+     * @param options
+     */
+    static create<ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion]>(options: JsonRpcClientOptions | JsonRpcProvider): Promise<JsonRpcClient<ChainApi>>;
+    /**
+     * Alias for __JsonRpcClient.create__
+     *
+     * @param options
+     */
+    static new<ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion]>(options: JsonRpcClientOptions | JsonRpcProvider): Promise<JsonRpcClient<ChainApi>>;
+    get options(): JsonRpcClientOptions;
+    /**
+     * @description Check connection status of the api instance
+     */
+    get status(): ConnectionStatus;
+    /**
+     * @description Get the JSON-RPC provider instance
+     */
+    get provider(): JsonRpcProvider;
+    connect(): Promise<this>;
+    disconnect(): Promise<void>;
+    /**
+     * @description Entry-point for executing JSON-RPCs to blockchain node.
+     *
+     * ```typescript
+     * const client = new JsonRpcClient('wss://rpc.polkadot.io');
+     * await client.connect();
+     *
+     * // Subscribe to new heads
+     * client.rpc.chain_subscribeNewHeads((header) => {
+     *   console.log(header);
+     * });
+     *
+     * // Execute arbitrary rpc method: `module_rpc_name`
+     * const result = await client.rpc.module_rpc_name();
+     * ```
+     */
+    get rpc(): ChainApi['rpc'];
+}

package/json-rpc/JsonRpcClient.js

@@ -0,0 +1,160 @@
+import { assert, EventEmitter, isFunction, isString } from '@dedot/utils';
+import { scaledResponses } from './scaledResponses.js';
+import { subscriptionsInfo } from './subscriptionsInfo.js';
+export const isJsonRpcProvider = (provider) => {
+    return (provider &&
+        isString(provider.status) &&
+        isFunction(provider.send) &&
+        isFunction(provider.subscribe) &&
+        isFunction(provider.connect) &&
+        isFunction(provider.disconnect));
+};
+export class JsonRpcClient extends EventEmitter {
+    #options;
+    #provider;
+    constructor(options) {
+        super();
+        if (isJsonRpcProvider(options)) {
+            this.#options = { provider: options };
+            this.#provider = options;
+        }
+        else {
+            this.#options = options;
+            this.#provider = options.provider;
+        }
+        assert(this.#provider, 'A JsonRpcProvider is required');
+    }
+    /**
+     * Factory method to create a new JsonRpcClient instance
+     *
+     * @param options
+     */
+    static async create(options) {
+        return new JsonRpcClient(options).connect();
+    }
+    /**
+     * Alias for __JsonRpcClient.create__
+     *
+     * @param options
+     */
+    static async new(options) {
+        return JsonRpcClient.create(options);
+    }
+    get options() {
+        return this.#options;
+    }
+    /**
+     * @description Check connection status of the api instance
+     */
+    get status() {
+        return this.provider.status;
+    }
+    /**
+     * @description Get the JSON-RPC provider instance
+     */
+    get provider() {
+        return this.#provider;
+    }
+    connect() {
+        return this.#doConnect();
+    }
+    async #doConnect() {
+        this.provider.on('connected', this.#onConnected);
+        this.provider.on('disconnected', this.#onDisconnected);
+        this.provider.on('reconnecting', this.#onReconnecting);
+        this.provider.on('error', this.#onError);
+        return new Promise((resolve, reject) => {
+            // @ts-ignore
+            this.once('connected', () => {
+                resolve(this);
+            });
+            if (this.status === 'connected') {
+                this.#onConnected().catch(reject);
+            }
+            else {
+                this.provider.connect().catch(reject);
+            }
+        });
+    }
+    #onConnected = async () => {
+        // @ts-ignore
+        this.emit('connected');
+    };
+    #onDisconnected = async () => {
+        // @ts-ignore
+        this.emit('disconnected');
+    };
+    #onReconnecting = async () => {
+        // @ts-ignore
+        this.emit('reconnecting');
+    };
+    #onError = async (e) => {
+        // @ts-ignore
+        this.emit('error', e);
+    };
+    async disconnect() {
+        await this.#provider.disconnect();
+        this.clearEvents();
+    }
+    /**
+     * @description Entry-point for executing JSON-RPCs to blockchain node.
+     *
+     * ```typescript
+     * const client = new JsonRpcClient('wss://rpc.polkadot.io');
+     * await client.connect();
+     *
+     * // Subscribe to new heads
+     * client.rpc.chain_subscribeNewHeads((header) => {
+     *   console.log(header);
+     * });
+     *
+     * // Execute arbitrary rpc method: `module_rpc_name`
+     * const result = await client.rpc.module_rpc_name();
+     * ```
+     */
+    get rpc() {
+        return new Proxy(this, {
+            get(target, property, receiver) {
+                const rpcMethod = property.toString();
+                return target.#doExecute(rpcMethod);
+            },
+        });
+    }
+    #doExecute(rpcName) {
+        const subscriptionInfo = this.options.subscriptions?.[rpcName] || subscriptionsInfo[rpcName];
+        const isSubscription = !!subscriptionInfo;
+        const fnRpc = async (...args) => {
+            const result = await this.provider.send(rpcName, args);
+            return this.#tryDecode(rpcName, result);
+        };
+        const fnSubRpc = async (...args) => {
+            const inArgs = args.slice();
+            const callback = inArgs.pop();
+            assert(isFunction(callback), 'A callback is required for subscription');
+            const onNewMessage = (error, result, subscription) => {
+                if (error) {
+                    console.error(error);
+                    return;
+                }
+                callback(this.#tryDecode(rpcName, result), subscription);
+            };
+            const [subname, unsubscribe] = subscriptionInfo;
+            const subscription = await this.provider.subscribe({ subname, subscribe: rpcName, params: inArgs, unsubscribe }, onNewMessage);
+            return async () => {
+                await subscription.unsubscribe();
+            };
+        };
+        return isSubscription ? fnSubRpc : fnRpc;
+    }
+    #tryDecode(rpcName, raw) {
+        if (raw === null) {
+            // We use `undefined` to represent Option::None in the client
+            return undefined;
+        }
+        const $maybeCodec = this.options.scaledResponses?.[rpcName] || scaledResponses[rpcName];
+        if ($maybeCodec) {
+            return $maybeCodec.tryDecode(raw);
+        }
+        return raw;
+    }
+}

package/json-rpc/group/ChainHead/BlockUsage.d.ts

@@ -0,0 +1,11 @@
+import { BlockHash } from '@dedot/codecs';
+/**
+ * A helper to track block hash usage
+ */
+export declare class BlockUsage {
+    #private;
+    use(blockHash: BlockHash): void;
+    release(blockHash: BlockHash): void;
+    usage(blockHash: BlockHash): number;
+    clear(): void;
+}

package/json-rpc/group/ChainHead/BlockUsage.js

@@ -0,0 +1,20 @@
+/**
+ * A helper to track block hash usage
+ */
+export class BlockUsage {
+    #usages = {};
+    use(blockHash) {
+        this.#usages[blockHash] = (this.#usages[blockHash] || 0) + 1;
+    }
+    release(blockHash) {
+        if (!this.#usages[blockHash])
+            return;
+        this.#usages[blockHash] -= 1;
+    }
+    usage(blockHash) {
+        return this.#usages[blockHash] || 0;
+    }
+    clear() {
+        this.#usages = {};
+    }
+}

package/json-rpc/group/ChainHead/ChainHead.d.ts

@@ -0,0 +1,70 @@
+import { BlockHash, Option } from '@dedot/codecs';
+import type { ChainHeadRuntimeVersion, OperationId, StorageQuery, StorageResult } from '@dedot/types/json-rpc';
+import { Deferred, HexString } from '@dedot/utils';
+import type { IJsonRpcClient } from '../../../types.js';
+import { JsonRpcGroup, type JsonRpcGroupOptions } from '../JsonRpcGroup.js';
+export type OperationHandler<T = any> = {
+    operationId: OperationId;
+    defer: Deferred<T>;
+    storageResults?: Array<StorageResult>;
+    hash: BlockHash;
+};
+export type PinnedBlock = {
+    hash: BlockHash;
+    number: number;
+    parent: BlockHash;
+    runtime?: ChainHeadRuntimeVersion;
+};
+export type ChainHeadEvent = 'newBlock' | 'bestBlock' | 'finalizedBlock' | 'bestChainChanged';
+export declare const MIN_FINALIZED_QUEUE_SIZE = 10;
+export declare class ChainHead extends JsonRpcGroup<ChainHeadEvent> {
+    #private;
+    constructor(client: IJsonRpcClient, options?: Partial<JsonRpcGroupOptions>);
+    runtimeVersion(): Promise<ChainHeadRuntimeVersion>;
+    bestRuntimeVersion(): Promise<ChainHeadRuntimeVersion>;
+    finalizedHash(): Promise<BlockHash>;
+    bestHash(): Promise<BlockHash>;
+    bestBlock(): Promise<PinnedBlock>;
+    finalizedBlock(): Promise<PinnedBlock>;
+    findBlock(hash: BlockHash): PinnedBlock | undefined;
+    isPinned(hash: BlockHash): boolean;
+    /**
+     * chainHead_unfollow
+     */
+    unfollow(): Promise<void>;
+    /**
+     * chainHead_follow
+     */
+    follow(): Promise<void>;
+    /**
+     * chainHead_body
+     */
+    body(at?: BlockHash): Promise<Array<HexString>>;
+    /**
+     * chainHead_call
+     */
+    call(func: string, params?: HexString, at?: BlockHash): Promise<HexString>;
+    /**
+     * chainHead_header
+     */
+    header(at?: BlockHash): Promise<Option<HexString>>;
+    /**
+     * chainHead_storage
+     */
+    storage(items: Array<StorageQuery>, childTrie?: string | null, at?: BlockHash): Promise<Array<StorageResult>>;
+    /**
+     * chainHead_stopOperation
+     * @protected
+     */
+    protected stopOperation(operationId: OperationId): Promise<void>;
+    /**
+     * chainHead_continue
+     * @protected
+     */
+    protected continue(operationId: OperationId): Promise<void>;
+    /**
+     * chainHead_unpin
+     * @protected
+     */
+    protected unpin(hashes: BlockHash | BlockHash[]): Promise<void>;
+}