@pezkuwi/api 16.5.6 → 16.5.8

package/build/rx/Api.js

@@ -0,0 +1,169 @@
+import { from } from 'rxjs';
+import { objectSpread } from '@pezkuwi/util';
+import { ApiBase } from '../base/index.js';
+import { toRxMethod } from './decorateMethod.js';
+/**
+ * # @pezkuwi/api/rx
+ *
+ * ## Overview
+ *
+ * @name ApiRx
+ *
+ * @description
+ * ApiRx is a powerful RxJS Observable wrapper around the RPC and interfaces on the Pezkuwi network. As a full Observable API, all interface calls return RxJS Observables, including the static `.create(...)`. In the same fashion and subscription-based methods return long-running Observables that update with the latest values.
+ *
+ * The API is well suited to real-time applications where the latest state is needed, unlocking the subscription-based features of Pezkuwi (and Bizinikiwi) clients. Some familiarity with RxJS is a requirement to use the API, however just understanding `.subscribe` and `.pipe` on Observables will unlock full-scale use thereof.
+ *
+ * @see [[ApiPromise]]
+ *
+ * ## Usage
+ *
+ * Making rpc calls -
+ * <BR>
+ *
+ * ```javascript
+ * import ApiRx from '@pezkuwi/api/rx';
+ *
+ * // initialize via Promise & static create
+ * const api = await ApiRx.create().toPromise();
+ *
+ * // make a call to retrieve the current network head
+ * api.rpc.chain.subscribeNewHeads().subscribe((header) => {
+ *   console.log(`Chain is at #${header.number}`);
+ * });
+ * ```
+ * <BR>
+ *
+ * Subscribing to chain state -
+ * <BR>
+ *
+ * ```javascript
+ * import { combineLatest, pairwise, switchMap } from 'rxjs';
+ * import { ApiRx, WsProvider } from '@pezkuwi/api';
+ *
+ *
+ * // initialize a provider with a specific endpoint
+ * const provider = new WsProvider('wss://example.com:9944')
+ *
+ * // initialize via isReady & new with specific provider
+ * new ApiRx({ provider })
+ *   .isReady
+ *   .pipe(
+ *     switchMap((api) =>
+ *       combineLatest([
+ *         api.query.timestamp.blockPeriod(),
+ *         api.query.timestamp.now().pipe(pairwise())
+ *       ])
+ *     )
+ *   )
+ *   .subscribe(([blockPeriod, timestamp]) => {
+ *      const elapsed = timestamp[1].toNumber() - timestamp[0].toNumber();
+ *      console.log(`timestamp ${timestamp[1]} \nelapsed ${elapsed} \n(${blockPeriod}s target)`);
+ *   });
+ * ```
+ * <BR>
+ *
+ * Submitting a transaction -
+ * <BR>
+ *
+ * ```javascript
+ * import { first, switchMap } from 'rxjs';
+ * import ApiRx from '@pezkuwi/api/rx';
+ *
+ * // import the test keyring (already has dev keys for Alice, Bob, Charlie, Eve & Ferdie)
+ * import testingPairs from '@pezkuwi/keyring/testingPairs';
+ * const keyring = testingPairs();
+ *
+ * // get api via Promise
+ * const api = await ApiRx.create().toPromise();
+ *
+ * // retrieve nonce for the account
+ * api.query.system
+ *   .account(keyring.alice.address)
+ *   .pipe(
+ *      first(),
+ *      // pipe nonce into transfer
+ *      switchMap(([nonce]) =>
+ *        api.tx.balances
+ *          // create transfer
+ *          .transferAllowDeath(keyring.bob.address, 12345)
+ *          // sign the transaction
+ *          .sign(keyring.alice, { nonce })
+ *          // send the transaction
+ *          .send()
+ *      )
+ *   )
+ *   // subscribe to overall result
+ *   .subscribe(({ status }) => {
+ *     if (status.isInBlock) {
+ *       console.log('Completed at block hash', status.asFinalized.toHex());
+ *     }
+ *   });
+ * ```
+ */
+export class ApiRx extends ApiBase {
+    #isReadyRx;
+    /**
+     * @description Create an instance of the ApiRx class
+     * @param options Options to create an instance. Can be either [[ApiOptions]] or [[WsProvider]]
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * import { switchMap } from 'rxjs';
+     * import Api from '@pezkuwi/api/rx';
+     *
+     * new Api().isReady
+     *   .pipe(
+     *     switchMap((api) =>
+     *       api.rpc.chain.subscribeNewHeads()
+     *   ))
+     *   .subscribe((header) => {
+     *     console.log(`new block #${header.number.toNumber()}`);
+     *   });
+     * ```
+     */
+    constructor(options) {
+        super(options, 'rxjs', toRxMethod);
+        this.#isReadyRx = from(
+        // You can create an observable from an event, however my mind groks this form better
+        new Promise((resolve) => {
+            super.on('ready', () => resolve(this));
+        }));
+    }
+    /**
+     * @description Creates an ApiRx instance using the supplied provider. Returns an Observable containing the actual Api instance.
+     * @param options options that is passed to the class constructor. Can be either [[ApiOptions]] or [[WsProvider]]
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * import { switchMap } from 'rxjs';
+     * import Api from '@pezkuwi/api/rx';
+     *
+     * Api.create()
+     *   .pipe(
+     *     switchMap((api) =>
+     *       api.rpc.chain.subscribeNewHeads()
+     *   ))
+     *   .subscribe((header) => {
+     *     console.log(`new block #${header.number.toNumber()}`);
+     *   });
+     * ```
+     */
+    static create(options) {
+        return new ApiRx(options).isReady;
+    }
+    /**
+     * @description Observable that returns the first time we are connected and loaded
+     */
+    get isReady() {
+        return this.#isReadyRx;
+    }
+    /**
+     * @description Returns a clone of this ApiRx instance (new underlying provider connection)
+     */
+    clone() {
+        return new ApiRx(objectSpread({}, this._options, { source: this }));
+    }
+}

package/build/rx/decorateMethod.d.ts

@@ -0,0 +1,3 @@
+import type { Codec } from '@pezkuwi/types/types';
+import type { DecorateFn } from '../types/index.js';
+export declare function toRxMethod<M extends DecorateFn<Codec>>(method: M): M;

package/build/rx/decorateMethod.js

@@ -0,0 +1,3 @@
+export function toRxMethod(method) {
+    return method;
+}

package/build/rx/index.d.ts

@@ -0,0 +1,2 @@
+export { ApiRx } from './Api.js';
+export { toRxMethod } from './decorateMethod.js';

package/build/rx/index.js

@@ -0,0 +1,2 @@
+export { ApiRx } from './Api.js';
+export { toRxMethod } from './decorateMethod.js';

package/build/submittable/Result.d.ts

@@ -0,0 +1,31 @@
+import type { BlockNumber, DispatchError, DispatchInfo, EventRecord, ExtrinsicStatus, Hash } from '@pezkuwi/types/interfaces';
+import type { AnyJson, ISubmittableResult } from '@pezkuwi/types/types';
+import type { SubmittableResultValue } from './types.js';
+export declare class SubmittableResult implements ISubmittableResult {
+    readonly dispatchError?: DispatchError | undefined;
+    readonly dispatchInfo?: DispatchInfo | undefined;
+    readonly internalError?: Error | undefined;
+    readonly events: EventRecord[];
+    readonly status: ExtrinsicStatus;
+    readonly txHash: Hash;
+    readonly txIndex?: number | undefined;
+    readonly blockNumber?: BlockNumber | undefined;
+    constructor({ blockNumber, dispatchError, dispatchInfo, events, internalError, status, txHash, txIndex }: SubmittableResultValue);
+    get isCompleted(): boolean;
+    get isError(): boolean;
+    get isFinalized(): boolean;
+    get isInBlock(): boolean;
+    get isWarning(): boolean;
+    /**
+     * @description Filters EventRecords for the specified method & section (there could be multiple)
+     */
+    filterRecords(section: string, method: string | string[]): EventRecord[];
+    /**
+     * @description Finds an EventRecord for the specified method & section
+     */
+    findRecord(section: string, method: string | string[]): EventRecord | undefined;
+    /**
+     * @description Creates a human representation of the output
+     */
+    toHuman(isExtended?: boolean): AnyJson;
+}

package/build/submittable/Result.js

@@ -0,0 +1,80 @@
+const recordIdentity = (record) => record;
+function filterAndApply(events, section, methods, onFound) {
+    return events
+        .filter(({ event }) => section === event.section &&
+        methods.includes(event.method))
+        .map((record) => onFound(record));
+}
+function getDispatchError({ event: { data: [dispatchError] } }) {
+    return dispatchError;
+}
+function getDispatchInfo({ event: { data, method } }) {
+    return method === 'ExtrinsicSuccess'
+        ? data[0]
+        : data[1];
+}
+function extractError(events = []) {
+    return filterAndApply(events, 'system', ['ExtrinsicFailed'], getDispatchError)[0];
+}
+function extractInfo(events = []) {
+    return filterAndApply(events, 'system', ['ExtrinsicFailed', 'ExtrinsicSuccess'], getDispatchInfo)[0];
+}
+export class SubmittableResult {
+    dispatchError;
+    dispatchInfo;
+    internalError;
+    events;
+    status;
+    txHash;
+    txIndex;
+    blockNumber;
+    constructor({ blockNumber, dispatchError, dispatchInfo, events, internalError, status, txHash, txIndex }) {
+        this.dispatchError = dispatchError || extractError(events);
+        this.dispatchInfo = dispatchInfo || extractInfo(events);
+        this.events = events || [];
+        this.internalError = internalError;
+        this.status = status;
+        this.txHash = txHash;
+        this.txIndex = txIndex;
+        this.blockNumber = blockNumber;
+    }
+    get isCompleted() {
+        return this.isError || this.status.isInBlock || this.status.isFinalized;
+    }
+    get isError() {
+        return this.status.isDropped || this.status.isFinalityTimeout || this.status.isInvalid || this.status.isUsurped;
+    }
+    get isFinalized() {
+        return this.status.isFinalized;
+    }
+    get isInBlock() {
+        return this.status.isInBlock;
+    }
+    get isWarning() {
+        return this.status.isRetracted;
+    }
+    /**
+     * @description Filters EventRecords for the specified method & section (there could be multiple)
+     */
+    filterRecords(section, method) {
+        return filterAndApply(this.events, section, Array.isArray(method) ? method : [method], recordIdentity);
+    }
+    /**
+     * @description Finds an EventRecord for the specified method & section
+     */
+    findRecord(section, method) {
+        return this.filterRecords(section, method)[0];
+    }
+    /**
+     * @description Creates a human representation of the output
+     */
+    toHuman(isExtended) {
+        return {
+            dispatchError: this.dispatchError?.toHuman(),
+            dispatchInfo: this.dispatchInfo?.toHuman(),
+            events: this.events.map((e) => e.toHuman(isExtended)),
+            internalError: this.internalError?.message.toString(),
+            status: this.status.toHuman(isExtended)
+        };
+    }
+}

package/build/submittable/createClass.d.ts

@@ -0,0 +1,12 @@
+import type { CodecClass } from '@pezkuwi/types/types';
+import type { ApiBase } from '../base/index.js';
+import type { ApiInterfaceRx, ApiTypes } from '../types/index.js';
+import type { SubmittableExtrinsic } from './types.js';
+interface SubmittableOptions<ApiType extends ApiTypes> {
+    api: ApiInterfaceRx;
+    apiType: ApiTypes;
+    blockHash?: Uint8Array | undefined;
+    decorateMethod: ApiBase<ApiType>['_decorateMethod'];
+}
+export declare function createClass<ApiType extends ApiTypes>({ api, apiType, blockHash, decorateMethod }: SubmittableOptions<ApiType>): CodecClass<SubmittableExtrinsic<ApiType>>;
+export {};

package/build/submittable/createClass.js

@@ -0,0 +1,274 @@
+import { catchError, first, map, mergeMap, of, switchMap, tap } from 'rxjs';
+import { identity, isBn, isFunction, isNumber, isString, isU8a, objectSpread } from '@pezkuwi/util';
+import { filterEvents, isKeyringPair } from '../util/index.js';
+import { SubmittableResult } from './Result.js';
+function makeEraOptions(api, registry, partialOptions, { header, mortalLength, nonce }) {
+    if (!header) {
+        if (partialOptions.era && !partialOptions.blockHash) {
+            throw new Error('Expected blockHash to be passed alongside non-immortal era options');
+        }
+        if (isNumber(partialOptions.era)) {
+            // since we have no header, it is immortal, remove any option overrides
+            // so we only supply the genesisHash and no era to the construction
+            delete partialOptions.era;
+            delete partialOptions.blockHash;
+        }
+        return makeSignOptions(api, partialOptions, { nonce });
+    }
+    return makeSignOptions(api, partialOptions, {
+        blockHash: header.hash,
+        era: registry.createTypeUnsafe('ExtrinsicEra', [{
+                current: header.number,
+                period: partialOptions.era || mortalLength
+            }]),
+        nonce
+    });
+}
+function makeSignAndSendOptions(partialOptions, statusCb) {
+    let options = {};
+    if (isFunction(partialOptions)) {
+        statusCb = partialOptions;
+    }
+    else {
+        options = objectSpread({}, partialOptions);
+    }
+    return [options, statusCb];
+}
+function makeSignOptions(api, partialOptions, extras) {
+    return objectSpread({ blockHash: api.genesisHash, genesisHash: api.genesisHash }, partialOptions, extras, { runtimeVersion: api.runtimeVersion, signedExtensions: api.registry.signedExtensions, version: api.extrinsicType });
+}
+function optionsOrNonce(partialOptions = {}) {
+    return isBn(partialOptions) || isNumber(partialOptions)
+        ? { nonce: partialOptions }
+        : partialOptions;
+}
+export function createClass({ api, apiType, blockHash, decorateMethod }) {
+    // an instance of the base extrinsic for us to extend
+    const ExtrinsicBase = api.registry.createClass('Extrinsic');
+    const extrinsicInfoMap = new WeakMap();
+    class Submittable extends ExtrinsicBase {
+        #ignoreStatusCb;
+        #transformResult = (identity);
+        constructor(registry, extrinsic) {
+            super(registry, extrinsic, { version: api.extrinsicType });
+            this.#ignoreStatusCb = apiType === 'rxjs';
+        }
+        get hasDryRun() {
+            return isFunction(api.rpc.system?.dryRun);
+        }
+        get hasPaymentInfo() {
+            return isFunction(api.call.transactionPaymentApi?.queryInfo);
+        }
+        // dry run an extrinsic
+        dryRun(account, optionsOrHash) {
+            if (!this.hasDryRun) {
+                throw new Error('The system.dryRun RPC call is not available in your environment');
+            }
+            if (blockHash || isString(optionsOrHash) || isU8a(optionsOrHash)) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                return decorateMethod(() => api.rpc.system.dryRun(this.toHex(), blockHash || optionsOrHash));
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-call
+            return decorateMethod(() => this.#observeSign(account, optionsOrHash).pipe(switchMap(() => api.rpc.system.dryRun(this.toHex()))))();
+        }
+        // calculate the payment info for this transaction (if signed and submitted)
+        paymentInfo(account, optionsOrHash) {
+            if (!this.hasPaymentInfo) {
+                throw new Error('The transactionPaymentApi.queryInfo runtime call is not available in your environment');
+            }
+            if (blockHash || isString(optionsOrHash) || isU8a(optionsOrHash)) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                return decorateMethod(() => api.callAt(blockHash || optionsOrHash).pipe(switchMap((callAt) => {
+                    const u8a = this.toU8a();
+                    return callAt.transactionPaymentApi.queryInfo(u8a, u8a.length);
+                })));
+            }
+            const [allOptions] = makeSignAndSendOptions(optionsOrHash);
+            const address = isKeyringPair(account) ? account.address : account.toString();
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-call
+            return decorateMethod(() => api.derive.tx.signingInfo(address, allOptions.nonce, allOptions.era).pipe(first(), switchMap((signingInfo) => {
+                // setup our options (same way as in signAndSend)
+                const eraOptions = makeEraOptions(api, this.registry, allOptions, signingInfo);
+                const signOptions = makeSignOptions(api, eraOptions, {});
+                // 1. Don't use the internal objects inside the new tx (hence toU8a)
+                // 2. Don't override the data from existing signed extrinsics
+                // 3. Ensure that this object stays intact, with no new sign after operation
+                const u8a = api.tx(this.toU8a()).signFake(address, signOptions).toU8a();
+                return api.call.transactionPaymentApi.queryInfo(u8a, u8a.length);
+            })))();
+        }
+        // send implementation for both immediate Hash and statusCb variants
+        send(statusCb) {
+            const isSubscription = api.hasSubscriptions && (this.#ignoreStatusCb || !!statusCb);
+            const updatedInfo = extrinsicInfoMap.get(this);
+            extrinsicInfoMap.delete(this);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-call
+            return decorateMethod(isSubscription
+                ? () => this.#observeSubscribe(updatedInfo)
+                : () => this.#observeSend(updatedInfo))(statusCb);
+        }
+        /**
+         * @description Signs a transaction, returning `this` to allow chaining. E.g.: `signAsync(...).send()`. Like `.signAndSend` this will retrieve the nonce and blockHash to send the tx with.
+        */
+        signAsync(account, partialOptions) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-call
+            return decorateMethod(() => this.#observeSign(account, partialOptions).pipe(map((info) => {
+                // If we got a full signed transaction from the signer, attach it
+                if (info.signedTransaction) {
+                    const extrinsic = new Submittable(api.registry, info.signedTransaction);
+                    extrinsicInfoMap.set(this, info);
+                    return extrinsic;
+                }
+                // Fallback if signer didn’t return signedTransaction
+                return this;
+            })))();
+        }
+        // signAndSend implementation for all 3 cases above
+        signAndSend(account, partialOptions, optionalStatusCb) {
+            const [options, statusCb] = makeSignAndSendOptions(partialOptions, optionalStatusCb);
+            const isSubscription = api.hasSubscriptions && (this.#ignoreStatusCb || !!statusCb);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-call
+            return decorateMethod(() => this.#observeSign(account, options).pipe(switchMap((info) => isSubscription
+                ? this.#observeSubscribe(info)
+                : this.#observeSend(info))) // FIXME This is wrong, SubmittableResult is _not_ a codec
+            )(statusCb);
+        }
+        // adds a transform to the result, applied before result is returned
+        withResultTransform(transform) {
+            this.#transformResult = transform;
+            return this;
+        }
+        #observeSign = (account, partialOptions) => {
+            const address = isKeyringPair(account) ? account.address : account.toString();
+            const options = optionsOrNonce(partialOptions);
+            return api.derive.tx.signingInfo(address, options.nonce, options.era).pipe(first(), mergeMap(async (signingInfo) => {
+                const eraOptions = makeEraOptions(api, this.registry, options, signingInfo);
+                let updateId = -1;
+                let signedTx = null;
+                if (isKeyringPair(account)) {
+                    this.sign(account, eraOptions);
+                }
+                else {
+                    const result = await this.#signViaSigner(address, eraOptions, signingInfo.header);
+                    updateId = result.id;
+                    if (result.signedTransaction) {
+                        signedTx = result.signedTransaction;
+                    }
+                }
+                return { options: eraOptions, signedTransaction: signedTx, updateId };
+            }));
+        };
+        #observeStatus = (txHash, status) => {
+            if (!status.isFinalized && !status.isInBlock) {
+                return of(this.#transformResult(new SubmittableResult({
+                    status,
+                    txHash
+                })));
+            }
+            const blockHash = status.isInBlock
+                ? status.asInBlock
+                : status.asFinalized;
+            return api.derive.tx.events(blockHash).pipe(map(({ block, events }) => this.#transformResult(new SubmittableResult({
+                ...filterEvents(txHash, block, events, status),
+                status,
+                txHash
+            }))), catchError((internalError) => of(this.#transformResult(new SubmittableResult({
+                internalError,
+                status,
+                txHash
+            })))));
+        };
+        #observeSend = (info) => {
+            return api.rpc.author.submitExtrinsic(info?.signedTransaction || this).pipe(tap((hash) => {
+                this.#updateSigner(hash, info);
+            }));
+        };
+        #observeSubscribe = (info) => {
+            const txHash = this.hash;
+            return api.rpc.author.submitAndWatchExtrinsic(info?.signedTransaction || this).pipe(switchMap((status) => this.#observeStatus(txHash, status)), tap((status) => {
+                this.#updateSigner(status, info);
+            }));
+        };
+        #signViaSigner = async (address, options, header) => {
+            const signer = options.signer || api.signer;
+            const allowCallDataAlteration = options.allowCallDataAlteration ?? true;
+            if (!signer) {
+                throw new Error('No signer specified, either via api.setSigner or via sign options. You possibly need to pass through an explicit keypair for the origin so it can be used for signing.');
+            }
+            const payload = this.registry.createTypeUnsafe('SignerPayload', [objectSpread({}, options, {
+                    address,
+                    blockNumber: header ? header.number : 0,
+                    method: this.method
+                })]);
+            let result;
+            if (isFunction(signer.signPayload)) {
+                result = await signer.signPayload(payload.toPayload());
+                if (result.signedTransaction && !options.withSignedTransaction) {
+                    throw new Error('The `signedTransaction` field may not be submitted when `withSignedTransaction` is disabled');
+                }
+                if (result.signedTransaction && options.withSignedTransaction) {
+                    const ext = this.registry.createTypeUnsafe('Extrinsic', [result.signedTransaction]);
+                    const newSignerPayload = this.registry.createTypeUnsafe('SignerPayload', [objectSpread({}, {
+                            address,
+                            assetId: ext.assetId && ext.assetId.isSome ? ext.assetId.toHex() : null,
+                            blockHash: payload.blockHash,
+                            blockNumber: header ? header.number : 0,
+                            era: ext.era.toHex(),
+                            genesisHash: payload.genesisHash,
+                            metadataHash: ext.metadataHash ? ext.metadataHash.toHex() : null,
+                            method: ext.method.toHex(),
+                            mode: ext.mode ? ext.mode.toHex() : null,
+                            nonce: ext.nonce.toHex(),
+                            runtimeVersion: payload.runtimeVersion,
+                            signedExtensions: payload.signedExtensions,
+                            tip: ext.tip ? ext.tip.toHex() : null,
+                            version: payload.version
+                        })]);
+                    if (!ext.isSigned) {
+                        throw new Error(`When using the signedTransaction field, the transaction must be signed. Recieved isSigned: ${ext.isSigned}`);
+                    }
+                    if (!allowCallDataAlteration) {
+                        this.#validateSignedTransaction(payload, ext);
+                    }
+                    // This is only used for signAsync - signAndSend does not need to adjust the super payload or
+                    // add the signature.
+                    super.addSignature(address, result.signature, newSignerPayload.toPayload());
+                    return { id: result.id, signedTransaction: result.signedTransaction };
+                }
+            }
+            else if (isFunction(signer.signRaw)) {
+                result = await signer.signRaw(payload.toRaw());
+            }
+            else {
+                throw new Error('Invalid signer interface, it should implement either signPayload or signRaw (or both)');
+            }
+            // Here we explicitly call `toPayload()` again instead of working with an object
+            // (reference) as passed to the signer. This means that we are sure that the
+            // payload data is not modified from our inputs, but the signer
+            super.addSignature(address, result.signature, payload.toPayload());
+            return { id: result.id };
+        };
+        #updateSigner = (status, info) => {
+            if (info && (info.updateId !== -1)) {
+                const { options, updateId } = info;
+                const signer = options.signer || api.signer;
+                if (signer && isFunction(signer.update)) {
+                    signer.update(updateId, status);
+                }
+            }
+        };
+        /**
+         * When a signer includes `signedTransaction` within the SignerResult this will validate
+         * specific fields within the signed extrinsic against the original payload that was passed
+         * to the signer.
+         */
+        #validateSignedTransaction = (signerPayload, signedExt) => {
+            const payload = signerPayload.toPayload();
+            const errMsg = (field) => `signAndSend: ${field} does not match the original payload`;
+            if (payload.method !== signedExt.method.toHex()) {
+                throw new Error(errMsg('call data'));
+            }
+        };
+    }
+    return Submittable;
+}

package/build/submittable/createSubmittable.d.ts

@@ -0,0 +1,8 @@
+import type { Call } from '@pezkuwi/types/interfaces';
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { ApiBase } from '../base/index.js';
+import type { ApiInterfaceRx, ApiTypes } from '../types/index.js';
+import type { SubmittableExtrinsic } from './types.js';
+type Creator<ApiType extends ApiTypes> = (extrinsic: Call | Uint8Array | string) => SubmittableExtrinsic<ApiType>;
+export declare function createSubmittable<ApiType extends ApiTypes>(apiType: ApiTypes, api: ApiInterfaceRx, decorateMethod: ApiBase<ApiType>['_decorateMethod'], registry?: Registry, blockHash?: Uint8Array): Creator<ApiType>;
+export {};

package/build/submittable/createSubmittable.js

@@ -0,0 +1,5 @@
+import { createClass } from './createClass.js';
+export function createSubmittable(apiType, api, decorateMethod, registry, blockHash) {
+    const Submittable = createClass({ api, apiType, blockHash, decorateMethod });
+    return (extrinsic) => new Submittable(registry || api.registry, extrinsic);
+}

package/build/submittable/index.d.ts

@@ -0,0 +1,2 @@
+export { createSubmittable } from './createSubmittable.js';
+export { SubmittableResult } from './Result.js';

package/build/submittable/index.js

@@ -0,0 +1,2 @@
+export { createSubmittable } from './createSubmittable.js';
+export { SubmittableResult } from './Result.js';

package/build/submittable/types.d.ts

@@ -0,0 +1 @@
+export type { AddressOrPair, SignerOptions, SubmittableDryRunResult, SubmittableExtrinsic, SubmittablePaymentResult, SubmittableResultResult, SubmittableResultSubscription, SubmittableResultValue } from '@pezkuwi/api-base/types';

package/build/submittable/types.js

@@ -0,0 +1 @@
+export {};

package/build/types/calls.d.ts

@@ -0,0 +1 @@
+export * from '@pezkuwi/api-base/types/calls';

package/build/types/calls.js

@@ -0,0 +1 @@
+export * from '@pezkuwi/api-base/types/calls';

package/build/types/consts.d.ts

@@ -0,0 +1 @@
+export * from '@pezkuwi/api-base/types/consts';

package/build/types/consts.js

@@ -0,0 +1 @@
+export * from '@pezkuwi/api-base/types/consts';

package/build/types/errors.d.ts

@@ -0,0 +1 @@
+export * from '@pezkuwi/api-base/types/errors';

package/build/types/errors.js

@@ -0,0 +1 @@
+export * from '@pezkuwi/api-base/types/errors';

package/build/types/events.d.ts

@@ -0,0 +1 @@
+export * from '@pezkuwi/api-base/types/events';

package/build/types/events.js

@@ -0,0 +1 @@
+export * from '@pezkuwi/api-base/types/events';