@dedot/api 0.0.1-alpha.32

package/executor/StorageQueryExecutor.js

@@ -0,0 +1,111 @@
+import { assert, isFunction } from '@dedot/utils';
+import { QueryableStorage } from '../storage/QueryableStorage.js';
+import { Executor } from './Executor.js';
+const DEFAULT_KEYS_PAGE_SIZE = 1000;
+const DEFAULT_ENTRIES_PAGE_SIZE = 250;
+/**
+ * @name StorageQueryExecutor
+ * @description Execute a query to on-chain storage
+ */
+export class StorageQueryExecutor extends Executor {
+    doExecute(pallet, storage) {
+        const entry = new QueryableStorage(this.registry, pallet, storage);
+        const extractArgs = (args) => {
+            const inArgs = args.slice();
+            const lastArg = args.at(-1);
+            const callback = isFunction(lastArg) ? inArgs.pop() : undefined;
+            return [inArgs, callback];
+        };
+        const getStorageKey = (...args) => {
+            const [inArgs] = extractArgs(args);
+            return entry.encodeKey(inArgs.at(0));
+        };
+        const getStorage = async (keys) => {
+            const results = await this.queryStorage(keys, this.atBlockHash);
+            return keys.reduce((o, key) => {
+                o[key] = entry.decodeValue(results[key]);
+                return o;
+            }, {});
+        };
+        const queryFn = async (...args) => {
+            const [inArgs, callback] = extractArgs(args);
+            const encodedKey = entry.encodeKey(inArgs.at(0));
+            // if a callback is passed, make a storage subscription and return an unsub function
+            if (callback) {
+                return await this.subscribeStorage([encodedKey], (changes) => {
+                    if (changes.length === 0)
+                        return;
+                    callback(entry.decodeValue(changes[0]));
+                });
+            }
+            else {
+                const results = await getStorage([encodedKey]);
+                return results[encodedKey];
+            }
+        };
+        queryFn.rawKey = getStorageKey;
+        queryFn.meta = {
+            pallet: entry.pallet.name,
+            palletIndex: entry.pallet.index,
+            ...entry.storageEntry,
+        };
+        const isMap = entry.storageEntry.type.tag === 'Map';
+        if (isMap) {
+            const queryMultiFn = async (...args) => {
+                const [inArgs, callback] = extractArgs(args);
+                const multiArgs = inArgs.at(0);
+                assert(Array.isArray(multiArgs), 'First param for multi query should be an array');
+                const encodedKeys = multiArgs.map((arg) => entry.encodeKey(arg));
+                // if a callback is passed, make a storage subscription and return an unsub function
+                if (callback) {
+                    return await this.subscribeStorage(encodedKeys, (changes) => {
+                        callback(changes.map((change) => entry.decodeValue(change)));
+                    });
+                }
+                else {
+                    const result = await getStorage(encodedKeys);
+                    return encodedKeys.map((key) => result[key]);
+                }
+            };
+            // @ts-ignore
+            queryFn.multi = queryMultiFn;
+            Object.assign(queryFn, this.exposeStorageMapMethods(entry));
+        }
+        return queryFn;
+    }
+    exposeStorageMapMethods(entry) {
+        const rawKeys = async (pagination) => {
+            const pageSize = pagination?.pageSize || DEFAULT_KEYS_PAGE_SIZE;
+            const startKey = pagination?.startKey || entry.prefixKey;
+            return await this.api.rpc.state_getKeysPaged(entry.prefixKey, pageSize, startKey, this.atBlockHash);
+        };
+        const pagedKeys = async (pagination) => {
+            const storageKeys = await rawKeys({ pageSize: DEFAULT_KEYS_PAGE_SIZE, ...pagination });
+            return storageKeys.map((key) => entry.decodeKey(key));
+        };
+        const pagedEntries = async (pagination) => {
+            const storageKeys = await rawKeys({ pageSize: DEFAULT_ENTRIES_PAGE_SIZE, ...pagination });
+            const storageMap = await this.queryStorage(storageKeys, this.atBlockHash);
+            return storageKeys.map((key) => [entry.decodeKey(key), entry.decodeValue(storageMap[key])]);
+        };
+        return { pagedKeys, pagedEntries };
+    }
+    async queryStorage(keys, hash) {
+        const changeSets = await this.api.rpc.state_queryStorageAt(keys, hash);
+        return changeSets[0].changes.reduce((o, [key, value]) => {
+            o[key] = value ?? undefined;
+            return o;
+        }, {});
+    }
+    subscribeStorage(keys, callback) {
+        const lastChanges = {};
+        return this.api.rpc.state_subscribeStorage(keys, (changeSet) => {
+            changeSet.changes.forEach(([key, value]) => {
+                if (lastChanges[key] !== value) {
+                    lastChanges[key] = value ?? undefined;
+                }
+            });
+            return callback(keys.map((key) => lastChanges[key]));
+        });
+    }
+}

package/executor/TxExecutor.d.ts

@@ -0,0 +1,10 @@
+import type { GenericSubstrateApi, GenericTxCall, IRuntimeTxCall } from '@dedot/types';
+import { Executor } from './Executor.js';
+/**
+ * @name TxExecutor
+ * @description Execute a transaction instruction, returns a submittable extrinsic
+ */
+export declare class TxExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
+    doExecute(pallet: string, functionName: string): GenericTxCall;
+    protected createExtrinsic(call: IRuntimeTxCall): any;
+}

package/executor/TxExecutor.js

@@ -0,0 +1,51 @@
+import { assert, stringCamelCase, stringPascalCase, UnknownApiError } from '@dedot/utils';
+import { SubmittableExtrinsic } from '../extrinsic/index.js';
+import { Executor } from './Executor.js';
+/**
+ * @name TxExecutor
+ * @description Execute a transaction instruction, returns a submittable extrinsic
+ */
+export class TxExecutor extends Executor {
+    doExecute(pallet, functionName) {
+        const targetPallet = this.getPallet(pallet);
+        assert(targetPallet.calls, new UnknownApiError(`Tx calls are not available for pallet ${targetPallet.name}`));
+        const txType = this.metadata.types[targetPallet.calls];
+        assert(txType.type.tag === 'Enum', new UnknownApiError('Tx type defs should be enum'));
+        const isFlatEnum = txType.type.value.members.every((m) => m.fields.length === 0);
+        const txCallDef = txType.type.value.members.find((m) => stringCamelCase(m.name) === functionName);
+        assert(txCallDef, new UnknownApiError(`Tx call spec not found for ${pallet}.${functionName}`));
+        const txCallFn = (...args) => {
+            let call;
+            if (isFlatEnum) {
+                call = {
+                    pallet: stringPascalCase(targetPallet.name),
+                    palletCall: stringPascalCase(txCallDef.name),
+                };
+            }
+            else {
+                const callParams = txCallDef.fields.reduce((o, { name }, idx) => {
+                    o[stringCamelCase(name)] = args[idx];
+                    return o;
+                }, {});
+                call = {
+                    pallet: stringPascalCase(targetPallet.name),
+                    palletCall: {
+                        name: stringPascalCase(txCallDef.name),
+                        params: callParams,
+                    },
+                };
+            }
+            return this.createExtrinsic(call);
+        };
+        txCallFn.meta = {
+            ...txCallDef,
+            fieldCodecs: txCallDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),
+            pallet: targetPallet.name,
+            palletIndex: targetPallet.index,
+        };
+        return txCallFn;
+    }
+    createExtrinsic(call) {
+        return new SubmittableExtrinsic(this.api, call);
+    }
+}

package/executor/index.d.ts

@@ -0,0 +1,10 @@
+export * from './Executor.js';
+export * from './ConstantExecutor.js';
+export * from './StorageQueryExecutor.js';
+export * from './ErrorExecutor.js';
+export * from './EventExecutor.js';
+export * from './RuntimeApiExecutor.js';
+export * from './TxExecutor.js';
+export * from './v2/StorageQueryExecutorV2.js';
+export * from './v2/RuntimeApiExecutorV2.js';
+export * from './v2/TxExecutorV2.js';

package/executor/index.js

@@ -0,0 +1,10 @@
+export * from './Executor.js';
+export * from './ConstantExecutor.js';
+export * from './StorageQueryExecutor.js';
+export * from './ErrorExecutor.js';
+export * from './EventExecutor.js';
+export * from './RuntimeApiExecutor.js';
+export * from './TxExecutor.js';
+export * from './v2/StorageQueryExecutorV2.js';
+export * from './v2/RuntimeApiExecutorV2.js';
+export * from './v2/TxExecutorV2.js';

package/executor/v2/RuntimeApiExecutorV2.d.ts

@@ -0,0 +1,14 @@
+import type { BlockHash } from '@dedot/codecs';
+import type { GenericSubstrateApi } from '@dedot/types';
+import { HexString } from '@dedot/utils';
+import { ChainHead } from '../../json-rpc/index.js';
+import { ISubstrateClientAt } from '../../types.js';
+import { RuntimeApiExecutor, StateCallParams } from '../RuntimeApiExecutor.js';
+/**
+ * @name RuntimeApiExecutorV2
+ */
+export declare class RuntimeApiExecutorV2<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends RuntimeApiExecutor<ChainApi> {
+    chainHead: ChainHead;
+    constructor(api: ISubstrateClientAt<ChainApi>, chainHead: ChainHead, atBlockHash?: BlockHash);
+    protected stateCall(callParams: StateCallParams): Promise<HexString>;
+}

package/executor/v2/RuntimeApiExecutorV2.js

@@ -0,0 +1,17 @@
+import { assert } from '@dedot/utils';
+import { RuntimeApiExecutor } from '../RuntimeApiExecutor.js';
+/**
+ * @name RuntimeApiExecutorV2
+ */
+export class RuntimeApiExecutorV2 extends RuntimeApiExecutor {
+    chainHead;
+    constructor(api, chainHead, atBlockHash) {
+        assert(api.rpcVersion === 'v2', 'Only supports JSON-RPC v2');
+        super(api, atBlockHash);
+        this.chainHead = chainHead;
+    }
+    stateCall(callParams) {
+        const { func, params, at } = callParams;
+        return this.chainHead.call(func, params, at);
+    }
+}

package/executor/v2/StorageQueryExecutorV2.d.ts

@@ -0,0 +1,17 @@
+import { BlockHash, Option, StorageData, StorageKey } from '@dedot/codecs';
+import type { AsyncMethod, Callback, GenericSubstrateApi } from '@dedot/types';
+import { HexString } from '@dedot/utils';
+import { ChainHead } from '../../json-rpc/index.js';
+import { QueryableStorage } from '../../storage/QueryableStorage.js';
+import { ISubstrateClientAt } from '../../types.js';
+import { StorageQueryExecutor } from '../StorageQueryExecutor.js';
+/**
+ * @name StorageQueryExecutorV2
+ */
+export declare class StorageQueryExecutorV2<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends StorageQueryExecutor<ChainApi> {
+    chainHead: ChainHead;
+    constructor(api: ISubstrateClientAt<ChainApi>, chainHead: ChainHead, atBlockHash?: BlockHash);
+    protected exposeStorageMapMethods(entry: QueryableStorage): Record<string, AsyncMethod>;
+    protected queryStorage(keys: StorageKey[], at?: BlockHash): Promise<Record<StorageKey, Option<StorageData>>>;
+    protected subscribeStorage(keys: HexString[], callback: Callback<Array<StorageData | undefined>>): Promise<() => Promise<void>>;
+}

package/executor/v2/StorageQueryExecutorV2.js

@@ -0,0 +1,61 @@
+import { assert } from '@dedot/utils';
+import { StorageQueryExecutor } from '../StorageQueryExecutor.js';
+/**
+ * @name StorageQueryExecutorV2
+ */
+export class StorageQueryExecutorV2 extends StorageQueryExecutor {
+    chainHead;
+    constructor(api, chainHead, atBlockHash) {
+        assert(api.rpcVersion === 'v2', 'Only supports JSON-RPC v2');
+        super(api, atBlockHash);
+        this.chainHead = chainHead;
+    }
+    exposeStorageMapMethods(entry) {
+        // chainHead_storage does not support pagination
+        // so for now we're trying to pull all entries from storage
+        // this might take a while for large storage
+        // TODO improve this, fallback to use `archive`-prefixed if available?
+        const entries = async () => {
+            const results = await this.chainHead.storage([{ type: 'descendantsValues', key: entry.prefixKey }]);
+            return results.map(({ key, value }) => [
+                entry.decodeKey(key),
+                entry.decodeValue(value),
+            ]);
+        };
+        return { entries };
+    }
+    async queryStorage(keys, at) {
+        const results = await this.chainHead.storage(keys.map((key) => ({ type: 'value', key })), undefined, at);
+        return results.reduce((o, r) => {
+            o[r.key] = (r.value ?? undefined);
+            return o;
+        }, {});
+    }
+    async subscribeStorage(keys, callback) {
+        let initialHash = await this.chainHead.bestHash();
+        let eventToListen = 'bestBlock';
+        // TODO subscribe to finalized data source
+        // initialHash = this.chainHead.finalizedHash;
+        // eventToListen = 'finalizedBlock';
+        const latestChanges = {};
+        const pull = async (hash) => {
+            const results = await this.queryStorage(keys, hash);
+            let changed = false;
+            keys.forEach((key) => {
+                const newValue = results[key];
+                if (latestChanges[key] === newValue)
+                    return;
+                changed = true;
+                latestChanges[key] = newValue;
+            });
+            if (!changed)
+                return;
+            callback(keys.map((key) => latestChanges[key]));
+        };
+        await pull(initialHash);
+        const unsub = this.chainHead.on(eventToListen, pull);
+        return async () => {
+            unsub();
+        };
+    }
+}

package/executor/v2/TxExecutorV2.d.ts

@@ -0,0 +1,11 @@
+import { IRuntimeTxCall, RpcVersion, VersionedGenericSubstrateApi } from '@dedot/types';
+import { DedotClient } from '../../client/index.js';
+import { TxExecutor } from '../TxExecutor.js';
+/**
+ * @name TxExecutor
+ * @description Execute a transaction instruction, returns a submittable extrinsic
+ */
+export declare class TxExecutorV2<ChainApi extends VersionedGenericSubstrateApi = VersionedGenericSubstrateApi> extends TxExecutor<ChainApi[RpcVersion]> {
+    constructor(api: DedotClient<ChainApi>);
+    protected createExtrinsic(call: IRuntimeTxCall): any;
+}

package/executor/v2/TxExecutorV2.js

@@ -0,0 +1,16 @@
+import { assert } from '@dedot/utils';
+import { SubmittableExtrinsicV2 } from '../../extrinsic/index.js';
+import { TxExecutor } from '../TxExecutor.js';
+/**
+ * @name TxExecutor
+ * @description Execute a transaction instruction, returns a submittable extrinsic
+ */
+export class TxExecutorV2 extends TxExecutor {
+    constructor(api) {
+        assert(api.rpcVersion === 'v2', 'Only supports JSON-RPC v2');
+        super(api);
+    }
+    createExtrinsic(call) {
+        return new SubmittableExtrinsicV2(this.api, call);
+    }
+}

package/extrinsic/extensions/ExtraSignedExtension.d.ts

@@ -0,0 +1,14 @@
+import { SignerPayloadJSON, SignerPayloadRaw } from '@polkadot/types/types';
+import * as $ from '@dedot/shape';
+import { HexString } from '@dedot/utils';
+import { SignedExtension } from './SignedExtension.js';
+export declare class ExtraSignedExtension extends SignedExtension<any[], any[]> {
+    #private;
+    init(): Promise<void>;
+    get identifier(): string;
+    get $Data(): $.AnyShape;
+    get $AdditionalSigned(): $.AnyShape;
+    get $Payload(): $.AnyShape;
+    toPayload(call?: HexString): SignerPayloadJSON;
+    toRawPayload(call?: HexString): SignerPayloadRaw;
+}

package/extrinsic/extensions/ExtraSignedExtension.js

@@ -0,0 +1,60 @@
+import * as $ from '@dedot/shape';
+import { assert, ensurePresence, u8aToHex } from '@dedot/utils';
+import { SignedExtension } from './SignedExtension.js';
+import { knownSignedExtensions } from './known/index.js';
+export class ExtraSignedExtension extends SignedExtension {
+    #signedExtensions;
+    async init() {
+        this.#signedExtensions = this.#getSignedExtensions();
+        await Promise.all(this.#signedExtensions.map((se) => se.init()));
+        this.data = this.#signedExtensions.map((se) => se.data);
+        this.additionalSigned = this.#signedExtensions.map((se) => se.additionalSigned);
+    }
+    get identifier() {
+        return 'ExtraSignedExtension';
+    }
+    get $Data() {
+        const { extraTypeId } = this.registry.metadata.extrinsic;
+        return ensurePresence(this.registry.findCodec(extraTypeId));
+    }
+    get $AdditionalSigned() {
+        const $AdditionalSignedCodecs = this.#signedExtensionDefs.map((se) => this.registry.findCodec(se.additionalSigned));
+        return $.Tuple(...$AdditionalSignedCodecs);
+    }
+    get $Payload() {
+        const { callTypeId } = this.registry.metadata.extrinsic;
+        const $Call = this.registry.findCodec(callTypeId);
+        return $.Tuple($Call, this.$Data, this.$AdditionalSigned);
+    }
+    get #signedExtensionDefs() {
+        return this.registry.metadata.extrinsic.signedExtensions;
+    }
+    #getSignedExtensions() {
+        return this.#signedExtensionDefs.map((extDef) => {
+            const { signedExtensions: userSignedExtensions = {} } = this.api.options;
+            const Extension = userSignedExtensions[extDef.ident] ||
+                knownSignedExtensions[extDef.ident];
+            assert(Extension, `SignedExtension for ${extDef.ident} not found`);
+            return new Extension(this.api, {
+                ...ensurePresence(this.options),
+                def: extDef,
+            });
+        });
+    }
+    toPayload(call = '0x') {
+        const signedExtensions = this.#signedExtensions.map((se) => se.identifier);
+        const { version } = this.registry.metadata.extrinsic;
+        return Object.assign({ address: this.options.signerAddress, signedExtensions, version, method: call }, ...this.#signedExtensions.map((se) => se.toPayload()));
+    }
+    toRawPayload(call = '0x') {
+        const payload = this.toPayload(call);
+        const $ToSignPayload = $.Tuple($.RawHex, this.$Data, this.$AdditionalSigned);
+        const toSignPayload = [call, this.data, this.additionalSigned];
+        const rawPayload = $ToSignPayload.tryEncode(toSignPayload);
+        return {
+            address: payload.address,
+            data: u8aToHex(rawPayload),
+            type: 'payload',
+        };
+    }
+}

package/extrinsic/extensions/SignedExtension.d.ts

@@ -0,0 +1,40 @@
+import { SignerPayloadJSON } from '@polkadot/types/types';
+import { PortableRegistry, SignedExtensionDefLatest } from '@dedot/codecs';
+import * as $ from '@dedot/shape';
+import { PayloadOptions } from '@dedot/types';
+import { ISubstrateClient } from '../../types.js';
+export interface ISignedExtension {
+    identifier: string;
+    $Data: $.AnyShape;
+    $AdditionalSigned: $.AnyShape;
+    data: any;
+    additionalSigned: any;
+    init(): Promise<void>;
+    registry: PortableRegistry;
+    toPayload(...additional: any[]): Partial<SignerPayloadJSON>;
+}
+interface SignedExtensionOptions {
+    def?: SignedExtensionDefLatest;
+    signerAddress?: string;
+    payloadOptions?: Partial<PayloadOptions>;
+}
+export declare abstract class SignedExtension<Data extends any = {}, AdditionalSigned extends any = []> implements ISignedExtension {
+    api: ISubstrateClient;
+    options?: SignedExtensionOptions | undefined;
+    data: Data;
+    additionalSigned: AdditionalSigned;
+    constructor(api: ISubstrateClient, options?: SignedExtensionOptions | undefined);
+    init(): Promise<void>;
+    get identifier(): string;
+    get $Data(): $.AnyShape;
+    get $AdditionalSigned(): $.AnyShape;
+    get registry(): PortableRegistry;
+    get signedExtensionDef(): {
+        ident: string;
+        typeId: number;
+        additionalSigned: number;
+    };
+    get payloadOptions(): Partial<PayloadOptions>;
+    toPayload(...args: any[]): Partial<SignerPayloadJSON>;
+}
+export {};

package/extrinsic/extensions/SignedExtension.js

@@ -0,0 +1,37 @@
+import { ensurePresence } from '@dedot/utils';
+export class SignedExtension {
+    api;
+    options;
+    data;
+    additionalSigned;
+    constructor(api, options) {
+        this.api = api;
+        this.options = options;
+        this.data = {};
+        this.additionalSigned = [];
+    }
+    async init() {
+        // TODO implement this method
+    }
+    get identifier() {
+        return this.signedExtensionDef.ident;
+    }
+    get $Data() {
+        return ensurePresence(this.registry.findCodec(this.signedExtensionDef.typeId));
+    }
+    get $AdditionalSigned() {
+        return ensurePresence(this.registry.findCodec(this.signedExtensionDef.additionalSigned));
+    }
+    get registry() {
+        return this.api.registry;
+    }
+    get signedExtensionDef() {
+        return ensurePresence(this.options.def);
+    }
+    get payloadOptions() {
+        return this.options?.payloadOptions || {};
+    }
+    toPayload(...args) {
+        return {};
+    }
+}

package/extrinsic/extensions/index.d.ts

@@ -0,0 +1,3 @@
+export * from './SignedExtension.js';
+export * from './known/index.js';
+export * from './ExtraSignedExtension.js';

package/extrinsic/extensions/index.js

@@ -0,0 +1,3 @@
+export * from './SignedExtension.js';
+export * from './known/index.js';
+export * from './ExtraSignedExtension.js';

package/extrinsic/extensions/known/ChargeAssetTxPayment.d.ts

@@ -0,0 +1,14 @@
+import { SignerPayloadJSON } from '@polkadot/types/types';
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @name ChargeAssetTxPayment
+ */
+export declare class ChargeAssetTxPayment extends SignedExtension<{
+    tip: bigint;
+    assetId?: number | object;
+}> {
+    #private;
+    init(): Promise<void>;
+    toPayload(): Partial<SignerPayloadJSON>;
+    $AssetId(): any;
+}

package/extrinsic/extensions/known/ChargeAssetTxPayment.js

@@ -0,0 +1,39 @@
+import { assert, bnToHex, u8aToHex } from '@dedot/utils';
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @name ChargeAssetTxPayment
+ */
+export class ChargeAssetTxPayment extends SignedExtension {
+    async init() {
+        const { tip, assetId } = this.payloadOptions;
+        this.data = {
+            tip: tip || 0n,
+            assetId,
+        };
+    }
+    toPayload() {
+        const { tip, assetId } = this.data;
+        return {
+            tip: bnToHex(tip),
+            // @ts-ignore
+            assetId: this.#encodeAssetId(assetId),
+        };
+    }
+    #encodeAssetId(assetId) {
+        if (assetId === null || assetId === undefined) {
+            return undefined;
+        }
+        return u8aToHex(this.$AssetId().tryEncode(assetId));
+    }
+    $AssetId() {
+        const extensionTypeDef = this.registry.findType(this.signedExtensionDef.typeId);
+        assert(extensionTypeDef.type.tag === 'Struct');
+        const assetIdTypeDef = extensionTypeDef.type.value.fields.find((f) => f.name === 'asset_id');
+        const $codec = this.registry.findCodec(assetIdTypeDef.typeId);
+        const codecMetadata = $codec.metadata[0];
+        if (codecMetadata.name === '$.option') {
+            return codecMetadata.args[0]; // inner shape
+        }
+        return $codec;
+    }
+}

package/extrinsic/extensions/known/ChargeTransactionPayment.d.ts

@@ -0,0 +1,6 @@
+import { SignerPayloadJSON } from '@polkadot/types/types';
+import { SignedExtension } from '../SignedExtension.js';
+export declare class ChargeTransactionPayment extends SignedExtension<bigint> {
+    init(): Promise<void>;
+    toPayload(): Partial<SignerPayloadJSON>;
+}

package/extrinsic/extensions/known/ChargeTransactionPayment.js

@@ -0,0 +1,12 @@
+import { bnToHex } from '@dedot/utils';
+import { SignedExtension } from '../SignedExtension.js';
+export class ChargeTransactionPayment extends SignedExtension {
+    async init() {
+        this.data = this.payloadOptions.tip || 0n;
+    }
+    toPayload() {
+        return {
+            tip: bnToHex(this.data),
+        };
+    }
+}

package/extrinsic/extensions/known/CheckGenesis.d.ts

@@ -0,0 +1,10 @@
+import { SignerPayloadJSON } from '@polkadot/types/types';
+import { Hash } from '@dedot/codecs';
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Genesis hash check to provide replay protection between different networks.
+ */
+export declare class CheckGenesis extends SignedExtension<{}, Hash> {
+    init(): Promise<void>;
+    toPayload(): Partial<SignerPayloadJSON>;
+}

package/extrinsic/extensions/known/CheckGenesis.js

@@ -0,0 +1,15 @@
+import { ensurePresence } from '@dedot/utils';
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Genesis hash check to provide replay protection between different networks.
+ */
+export class CheckGenesis extends SignedExtension {
+    async init() {
+        this.additionalSigned = ensurePresence(this.api.genesisHash);
+    }
+    toPayload() {
+        return {
+            genesisHash: this.additionalSigned,
+        };
+    }
+}

package/extrinsic/extensions/known/CheckMortality.d.ts

@@ -0,0 +1,15 @@
+import { SignerPayloadJSON } from '@polkadot/types/types';
+import { EraLike, Hash } from '@dedot/codecs';
+import { SignedExtension } from '../SignedExtension.js';
+export declare const MAX_FINALITY_LAG: number;
+export declare const FALLBACK_MAX_HASH_COUNT: number;
+export declare const FALLBACK_PERIOD: number;
+export declare const MORTAL_PERIOD: number;
+/**
+ * @description Check for transaction mortality.
+ */
+export declare class CheckMortality extends SignedExtension<EraLike, Hash> {
+    #private;
+    init(): Promise<void>;
+    toPayload(): Partial<SignerPayloadJSON>;
+}