@pezkuwi/api 16.5.5 → 16.5.8

package/cjs/submittable/createClass.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClass = createClass;
+const rxjs_1 = require("rxjs");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const Result_js_1 = require("./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 ((0, util_1.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 ((0, util_1.isFunction)(partialOptions)) {
+        statusCb = partialOptions;
+    }
+    else {
+        options = (0, util_1.objectSpread)({}, partialOptions);
+    }
+    return [options, statusCb];
+}
+function makeSignOptions(api, partialOptions, extras) {
+    return (0, util_1.objectSpread)({ blockHash: api.genesisHash, genesisHash: api.genesisHash }, partialOptions, extras, { runtimeVersion: api.runtimeVersion, signedExtensions: api.registry.signedExtensions, version: api.extrinsicType });
+}
+function optionsOrNonce(partialOptions = {}) {
+    return (0, util_1.isBn)(partialOptions) || (0, util_1.isNumber)(partialOptions)
+        ? { nonce: partialOptions }
+        : partialOptions;
+}
+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 = (util_1.identity);
+        constructor(registry, extrinsic) {
+            super(registry, extrinsic, { version: api.extrinsicType });
+            this.#ignoreStatusCb = apiType === 'rxjs';
+        }
+        get hasDryRun() {
+            return (0, util_1.isFunction)(api.rpc.system?.dryRun);
+        }
+        get hasPaymentInfo() {
+            return (0, util_1.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 || (0, util_1.isString)(optionsOrHash) || (0, util_1.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((0, rxjs_1.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 || (0, util_1.isString)(optionsOrHash) || (0, util_1.isU8a)(optionsOrHash)) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                return decorateMethod(() => api.callAt(blockHash || optionsOrHash).pipe((0, rxjs_1.switchMap)((callAt) => {
+                    const u8a = this.toU8a();
+                    return callAt.transactionPaymentApi.queryInfo(u8a, u8a.length);
+                })));
+            }
+            const [allOptions] = makeSignAndSendOptions(optionsOrHash);
+            const address = (0, index_js_1.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((0, rxjs_1.first)(), (0, rxjs_1.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((0, rxjs_1.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((0, rxjs_1.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 = (0, index_js_1.isKeyringPair)(account) ? account.address : account.toString();
+            const options = optionsOrNonce(partialOptions);
+            return api.derive.tx.signingInfo(address, options.nonce, options.era).pipe((0, rxjs_1.first)(), (0, rxjs_1.mergeMap)(async (signingInfo) => {
+                const eraOptions = makeEraOptions(api, this.registry, options, signingInfo);
+                let updateId = -1;
+                let signedTx = null;
+                if ((0, index_js_1.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 (0, rxjs_1.of)(this.#transformResult(new Result_js_1.SubmittableResult({
+                    status,
+                    txHash
+                })));
+            }
+            const blockHash = status.isInBlock
+                ? status.asInBlock
+                : status.asFinalized;
+            return api.derive.tx.events(blockHash).pipe((0, rxjs_1.map)(({ block, events }) => this.#transformResult(new Result_js_1.SubmittableResult({
+                ...(0, index_js_1.filterEvents)(txHash, block, events, status),
+                status,
+                txHash
+            }))), (0, rxjs_1.catchError)((internalError) => (0, rxjs_1.of)(this.#transformResult(new Result_js_1.SubmittableResult({
+                internalError,
+                status,
+                txHash
+            })))));
+        };
+        #observeSend = (info) => {
+            return api.rpc.author.submitExtrinsic(info?.signedTransaction || this).pipe((0, rxjs_1.tap)((hash) => {
+                this.#updateSigner(hash, info);
+            }));
+        };
+        #observeSubscribe = (info) => {
+            const txHash = this.hash;
+            return api.rpc.author.submitAndWatchExtrinsic(info?.signedTransaction || this).pipe((0, rxjs_1.switchMap)((status) => this.#observeStatus(txHash, status)), (0, rxjs_1.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', [(0, util_1.objectSpread)({}, options, {
+                    address,
+                    blockNumber: header ? header.number : 0,
+                    method: this.method
+                })]);
+            let result;
+            if ((0, util_1.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', [(0, util_1.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 ((0, util_1.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 && (0, util_1.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/cjs/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/cjs/submittable/createSubmittable.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSubmittable = createSubmittable;
+const createClass_js_1 = require("./createClass.js");
+function createSubmittable(apiType, api, decorateMethod, registry, blockHash) {
+    const Submittable = (0, createClass_js_1.createClass)({ api, apiType, blockHash, decorateMethod });
+    return (extrinsic) => new Submittable(registry || api.registry, extrinsic);
+}

package/cjs/submittable/index.d.ts

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

package/cjs/submittable/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubmittableResult = exports.createSubmittable = void 0;
+var createSubmittable_js_1 = require("./createSubmittable.js");
+Object.defineProperty(exports, "createSubmittable", { enumerable: true, get: function () { return createSubmittable_js_1.createSubmittable; } });
+var Result_js_1 = require("./Result.js");
+Object.defineProperty(exports, "SubmittableResult", { enumerable: true, get: function () { return Result_js_1.SubmittableResult; } });

package/cjs/submittable/types.d.ts

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

package/cjs/submittable/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/calls.d.ts

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

package/cjs/types/calls.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("@pezkuwi/api-base/types/calls"), exports);

package/cjs/types/consts.d.ts

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

package/cjs/types/consts.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("@pezkuwi/api-base/types/consts"), exports);

package/cjs/types/errors.d.ts

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

package/cjs/types/errors.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("@pezkuwi/api-base/types/errors"), exports);

package/cjs/types/events.d.ts

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

package/cjs/types/events.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("@pezkuwi/api-base/types/events"), exports);

package/cjs/types/index.d.ts

@@ -0,0 +1,114 @@
+import type { ApiTypes, DeriveCustom, QueryableStorageMulti } from '@pezkuwi/api-base/types';
+import type { ApiInterfaceRx as ApiInterfaceBase } from '@pezkuwi/api-base/types/api';
+import type { QueryableCalls } from '@pezkuwi/api-base/types/calls';
+import type { QueryableConsts } from '@pezkuwi/api-base/types/consts';
+import type { DecoratedErrors } from '@pezkuwi/api-base/types/errors';
+import type { DecoratedEvents } from '@pezkuwi/api-base/types/events';
+import type { QueryableStorage } from '@pezkuwi/api-base/types/storage';
+import type { ProviderInterface, ProviderInterfaceEmitted } from '@pezkuwi/rpc-provider/types';
+import type { ExtDef } from '@pezkuwi/types/extrinsic/signedExtensions/types';
+import type { Call, Extrinsic, Hash, RuntimeVersionPartial } from '@pezkuwi/types/interfaces';
+import type { CallFunction, DefinitionRpc, DefinitionRpcSub, DefinitionsCall, RegisteredTypes, Registry, RegistryError, SignatureOptions, Signer } from '@pezkuwi/types/types';
+import type { BN } from '@pezkuwi/util';
+import type { HexString } from '@pezkuwi/util/types';
+import type { ApiBase } from '../base/index.js';
+import type { SubmittableExtrinsic } from '../types/submittable.js';
+import type { AllDerives } from '../util/decorate.js';
+export type { Signer, SignerResult } from '@pezkuwi/types/types';
+export { ApiBase } from '../base/index.js';
+export * from '@pezkuwi/api/types/calls';
+export * from '@pezkuwi/api/types/consts';
+export * from '@pezkuwi/api/types/errors';
+export * from '@pezkuwi/api/types/events';
+export * from '@pezkuwi/api/types/storage';
+export * from '@pezkuwi/api/types/submittable';
+export * from '@pezkuwi/api-base/types';
+export interface ApiInterfaceRx extends ApiInterfaceBase {
+    derive: AllDerives<'rxjs'>;
+}
+export interface ApiOptions extends RegisteredTypes {
+    /**
+     * @description Add custom derives to be injected
+     */
+    derives?: DeriveCustom;
+    /**
+     * @description Control the initialization of the wasm libraries. When not specified, it defaults to `true`, initializing the wasm libraries, set to `false` to not initialize wasm. (No sr25519 support)
+     */
+    initWasm?: boolean;
+    /**
+     * @description Controls the checking of storage values once they have been contructed. When not specified this defaults to `true`. Set to `false` to forgo any checking on storage results.
+     */
+    isPedantic?: boolean;
+    /**
+     * @description pre-bundles is a map of 'genesis hash and runtime spec version' as key to a metadata hex string
+     * if genesis hash and runtime spec version matches, then use metadata, else fetch it from chain
+     */
+    metadata?: Record<string, HexString>;
+    /**
+     * @description Don't display any warnings on initialization (missing RPC methods & runtime calls)
+     */
+    noInitWarn?: boolean;
+    /**
+     * @description Transport Provider from rpc-provider. If not specified, it will default to
+     * connecting to a WsProvider connecting localhost with the default port, i.e. `ws://127.0.0.1:9944`
+     */
+    provider?: ProviderInterface;
+    /**
+     * @description A type registry to use along with this instance
+     */
+    registry?: Registry;
+    /**
+     * @description User-defined RPC methods
+     */
+    rpc?: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>;
+    /**
+     * @description Defines the size of the cache for the rpc-core. Defaults to 1024 * 10 * 10.
+     */
+    rpcCacheCapacity?: number;
+    /**
+     * @description Overrides for state_call usage (this will be removed in some future version)
+     */
+    runtime?: DefinitionsCall;
+    /**
+     * @description Any chain-specific signed extensions that are now well-known
+     */
+    signedExtensions?: ExtDef;
+    /**
+     * @description An external signer which will be used to sign extrinsic when account passed in is not KeyringPair
+     */
+    signer?: Signer;
+    /**
+     * @description The source object to use for runtime information (only used when cloning)
+     */
+    source?: ApiBase<any>;
+    /**
+     * @description Throws an error when the initial connection fails (same as isReadyOrError)
+     */
+    throwOnConnect?: boolean;
+    /**
+     * @description Throws an error when some types are unknown (useful with throwOnConnect)
+     */
+    throwOnUnknown?: boolean;
+}
+export type ApiInterfaceEvents = ProviderInterfaceEmitted | 'ready' | 'decorated';
+export interface SignerOptions extends SignatureOptions {
+    blockNumber: BN;
+    genesisHash: Hash;
+}
+export interface ApiDecoration<ApiType extends ApiTypes> {
+    call: QueryableCalls<ApiType>;
+    consts: QueryableConsts<ApiType>;
+    errors: DecoratedErrors<ApiType>;
+    events: DecoratedEvents<ApiType>;
+    query: QueryableStorage<ApiType>;
+    registry: Registry;
+    runtimeVersion: RuntimeVersionPartial;
+    rx: {
+        call: QueryableCalls<'rxjs'>;
+        query: QueryableStorage<'rxjs'>;
+    };
+    tx: (extrinsic: Call | Extrinsic | Uint8Array | string) => SubmittableExtrinsic<ApiType>;
+    findCall(callIndex: Uint8Array | string): CallFunction;
+    findError(errorIndex: Uint8Array | string): RegistryError;
+    queryMulti: QueryableStorageMulti<ApiType>;
+}

package/cjs/types/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiBase = void 0;
+const tslib_1 = require("tslib");
+var index_js_1 = require("../base/index.js");
+Object.defineProperty(exports, "ApiBase", { enumerable: true, get: function () { return index_js_1.ApiBase; } });
+tslib_1.__exportStar(require("@pezkuwi/api/types/calls"), exports);
+tslib_1.__exportStar(require("@pezkuwi/api/types/consts"), exports);
+tslib_1.__exportStar(require("@pezkuwi/api/types/errors"), exports);
+tslib_1.__exportStar(require("@pezkuwi/api/types/events"), exports);
+tslib_1.__exportStar(require("@pezkuwi/api/types/storage"), exports);
+tslib_1.__exportStar(require("@pezkuwi/api/types/submittable"), exports);
+tslib_1.__exportStar(require("@pezkuwi/api-base/types"), exports);

package/cjs/types/storage.d.ts

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

package/cjs/types/storage.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("@pezkuwi/api-base/types/storage"), exports);

package/cjs/types/submittable.d.ts

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

package/cjs/types/submittable.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("@pezkuwi/api-base/types/submittable"), exports);

package/cjs/util/augmentObject.d.ts

@@ -0,0 +1,9 @@
+type Sections<T> = Record<string, Methods<T>>;
+type Methods<T> = Record<string, T>;
+/**
+ * @description Takes a decorated api section (e.g. api.tx) and augment it with the details. It does not override what is
+ * already available, but rather just adds new missing items into the result object.
+ * @internal
+ */
+export declare function augmentObject<T>(prefix: string | null, src: Sections<T>, dst: Sections<T>, fromEmpty?: boolean): Sections<T>;
+export {};

package/cjs/util/augmentObject.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.augmentObject = augmentObject;
+const util_1 = require("@pezkuwi/util");
+const l = (0, util_1.logger)('api/augment');
+function logLength(type, values, and = []) {
+    return values.length
+        ? ` ${values.length} ${type}${and.length ? ' and' : ''}`
+        : '';
+}
+function logValues(type, values) {
+    return values.length
+        ? `\n\t${type.padStart(7)}: ${values.sort().join(', ')}`
+        : '';
+}
+function warn(prefix, type, [added, removed]) {
+    if (added.length || removed.length) {
+        l.warn(`api.${prefix}: Found${logLength('added', added, removed)}${logLength('removed', removed)} ${type}:${logValues('added', added)}${logValues('removed', removed)}`);
+    }
+}
+function findSectionExcludes(a, b) {
+    return a.filter((s) => !b.includes(s));
+}
+function findSectionIncludes(a, b) {
+    return a.filter((s) => b.includes(s));
+}
+function extractSections(src, dst) {
+    const srcSections = Object.keys(src);
+    const dstSections = Object.keys(dst);
+    return [
+        findSectionExcludes(srcSections, dstSections),
+        findSectionExcludes(dstSections, srcSections)
+    ];
+}
+function findMethodExcludes(src, dst) {
+    const srcSections = Object.keys(src);
+    const dstSections = findSectionIncludes(Object.keys(dst), srcSections);
+    const excludes = [];
+    for (let s = 0, scount = dstSections.length; s < scount; s++) {
+        const section = dstSections[s];
+        const srcMethods = Object.keys(src[section]);
+        const dstMethods = Object.keys(dst[section]);
+        for (let d = 0, mcount = dstMethods.length; d < mcount; d++) {
+            const method = dstMethods[d];
+            if (!srcMethods.includes(method)) {
+                excludes.push(`${section}.${method}`);
+            }
+        }
+    }
+    return excludes;
+}
+function extractMethods(src, dst) {
+    return [
+        findMethodExcludes(dst, src),
+        findMethodExcludes(src, dst)
+    ];
+}
+/**
+ * @description Takes a decorated api section (e.g. api.tx) and augment it with the details. It does not override what is
+ * already available, but rather just adds new missing items into the result object.
+ * @internal
+ */
+function augmentObject(prefix, src, dst, fromEmpty = false) {
+    fromEmpty && (0, util_1.objectClear)(dst);
+    // NOTE: This part is slightly problematic since it will get the
+    // values for at least all the sections and the names of the methods
+    // (Since methods won't be decorated before lazy, this _may_ be ok)
+    if (prefix && Object.keys(dst).length) {
+        warn(prefix, 'modules', extractSections(src, dst));
+        warn(prefix, 'calls', extractMethods(src, dst));
+    }
+    const sections = Object.keys(src);
+    for (let i = 0, count = sections.length; i < count; i++) {
+        const section = sections[i];
+        const methods = src[section];
+        // We don't set here with a lazy interface, we decorate based
+        // on the top-level structure (this bypasses adding lazy onto lazy)
+        if (!dst[section]) {
+            dst[section] = {};
+        }
+        (0, util_1.lazyMethods)(dst[section], Object.keys(methods), (m) => methods[m]);
+    }
+    return dst;
+}

package/cjs/util/decorate.d.ts

@@ -0,0 +1,16 @@
+import type { ExactDerive } from '@pezkuwi/api-derive';
+import type { AnyFunction } from '@pezkuwi/types/types';
+import type { ApiTypes, DecorateMethod, MethodResult } from '../types/index.js';
+type AnyDeriveSection = Record<string, AnyFunction>;
+type AnyDerive = Record<string, AnyDeriveSection>;
+type DeriveSection<ApiType extends ApiTypes, Section extends AnyDeriveSection> = {
+    [M in keyof Section]: MethodResult<ApiType, Section[M]>;
+};
+export type AllDerives<ApiType extends ApiTypes> = {
+    [S in keyof ExactDerive]: DeriveSection<ApiType, ExactDerive[S]>;
+};
+/**
+ * This is a section decorator which keeps all type information.
+ */
+export declare function decorateDeriveSections<ApiType extends ApiTypes>(decorateMethod: DecorateMethod<ApiType>, derives: AnyDerive): AllDerives<ApiType>;
+export {};

package/cjs/util/decorate.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateDeriveSections = decorateDeriveSections;
+const api_derive_1 = require("@pezkuwi/api-derive");
+/**
+ * This is a section decorator which keeps all type information.
+ */
+function decorateDeriveSections(decorateMethod, derives) {
+    const getKeys = (s) => Object.keys(derives[s]);
+    const creator = (s, m) => decorateMethod(derives[s][m]);
+    const result = {};
+    const names = Object.keys(derives);
+    for (let i = 0, count = names.length; i < count; i++) {
+        (0, api_derive_1.lazyDeriveSection)(result, names[i], getKeys, creator);
+    }
+    return result;
+}

package/cjs/util/filterEvents.d.ts

@@ -0,0 +1,6 @@
+import type { BlockNumber, EventRecord, ExtrinsicStatus, H256, SignedBlock } from '@pezkuwi/types/interfaces';
+export declare function filterEvents(txHash: H256, { block: { extrinsics, header } }: SignedBlock, allEvents: EventRecord[], status: ExtrinsicStatus): {
+    events?: EventRecord[];
+    txIndex?: number;
+    blockNumber?: BlockNumber;
+};