@pezkuwi/api 16.5.5 → 16.5.8

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.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.js

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

package/build/submittable/types.js

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

package/build/types/calls.js

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

package/build/types/consts.js

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

package/build/types/errors.js

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

package/build/types/events.js

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

package/build/types/index.js

@@ -0,0 +1,8 @@
+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';

package/build/types/storage.js

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

package/build/types/submittable.js

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

package/build/util/augmentObject.js

@@ -0,0 +1,81 @@
+import { lazyMethods, logger, objectClear } from '@pezkuwi/util';
+const l = 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
+ */
+export function augmentObject(prefix, src, dst, fromEmpty = false) {
+    fromEmpty && 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] = {};
+        }
+        lazyMethods(dst[section], Object.keys(methods), (m) => methods[m]);
+    }
+    return dst;
+}

package/build/util/decorate.js

@@ -0,0 +1,14 @@
+import { lazyDeriveSection } from '@pezkuwi/api-derive';
+/**
+ * This is a section decorator which keeps all type information.
+ */
+export 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++) {
+        lazyDeriveSection(result, names[i], getKeys, creator);
+    }
+    return result;
+}

package/build/util/filterEvents.js

@@ -0,0 +1,22 @@
+import { isCompact } from '@pezkuwi/util';
+import { l } from './logging.js';
+export function filterEvents(txHash, { block: { extrinsics, header } }, allEvents, status) {
+    // extrinsics to hashes
+    for (const [txIndex, x] of extrinsics.entries()) {
+        if (x.hash.eq(txHash)) {
+            return {
+                blockNumber: isCompact(header.number) ? header.number.unwrap() : header.number,
+                events: allEvents.filter(({ phase }) => phase.isApplyExtrinsic &&
+                    phase.asApplyExtrinsic.eqn(txIndex)),
+                txIndex
+            };
+        }
+    }
+    // if we do get the block after finalized, it _should_ be there
+    // only warn on filtering with isInBlock (finalization finalizes after)
+    if (status.isInBlock) {
+        const allHashes = extrinsics.map((x) => x.hash.toHex());
+        l.warn(`block ${header.hash.toHex()}: Unable to find extrinsic ${txHash.toHex()} inside ${allHashes.join(', ')}`);
+    }
+    return {};
+}

package/build/util/index.js

@@ -0,0 +1,4 @@
+export { filterEvents } from './filterEvents.js';
+export { isKeyringPair } from './isKeyringPair.js';
+export { l } from './logging.js';
+export * from './decorate.js';

package/build/util/isKeyringPair.js

@@ -0,0 +1,4 @@
+import { isFunction } from '@pezkuwi/util';
+export function isKeyringPair(account) {
+    return isFunction(account.sign);
+}

package/build/util/logging.js

@@ -0,0 +1,2 @@
+import { logger } from '@pezkuwi/util';
+export const l = /*#__PURE__*/ logger('api/util');

package/build/util/validate.js

@@ -0,0 +1,23 @@
+import { isUndefined } from '@pezkuwi/util';
+function sig({ lookup }, { method, section }, args) {
+    return `${section}.${method}(${args.map((a) => lookup.getTypeDef(a).type).join(', ')})`;
+}
+export function extractStorageArgs(registry, creator, _args) {
+    const args = _args.filter((a) => !isUndefined(a));
+    if (creator.meta.type.isPlain) {
+        if (args.length !== 0) {
+            throw new Error(`${sig(registry, creator, [])} does not take any arguments, ${args.length} found`);
+        }
+    }
+    else {
+        const { hashers, key } = creator.meta.type.asMap;
+        const keys = hashers.length === 1
+            ? [key]
+            : registry.lookup.getSiType(key).def.asTuple.map((t) => t);
+        if (args.length !== keys.length) {
+            throw new Error(`${sig(registry, creator, keys)} is a map, requiring ${keys.length} arguments, ${args.length} found`);
+        }
+    }
+    // pass as tuple
+    return [creator, args];
+}

package/build-deno/README.md

@@ -0,0 +1,95 @@
+# @pezkuwi/api
+
+The Pezkuwi-JS API provides easy-to-use wrappers around JSONRPC calls that flow from an application to a node. It handles all the encoding and decoding or parameters, provides access to RPC functions and allows for the query of chain state and the submission of transactions.
+
+The API wrappers provide a standard interface for use -
+
+- A static `.create(<optional ApiOptions>)` that returns an API instance when connected, decorated and ready-to use. ApiOptions can include an optional WsProvider and optional custom type definitions `{ provider: <Optional WsProvider>, types: <Optional RegistryTypes> }`.
+- The above is just a wrapper for `new Api(<optional ApiOptions>) `, exposing the `isReady` getter
+- `api.rpc.<section>.<method>` provides access to actual RPC calls, be it for queries, submission or retrieving chain information
+  - [RPC (node interface)](https://js.pezkuwichain.app/docs/bizinikiwi/rpc)
+- `api.query.<section>.<method>` provides access to chain state queries. These are dynamically populated based on what the runtime provides
+  - [Storage chain state (runtime node interface)](https://js.pezkuwichain.app/docs/bizinikiwi/storage)
+- `api.tx.<section>.<method>` provides the ability to create a transaction, like chain state, this list is populated from a runtime query
+  - [Extrinsics (runtime node interface)](https://js.pezkuwichain.app/docs/bizinikiwi/extrinsics)
+- `api.consts.<section>.<constant>` provides access to the module constants (parameter types).
+  - [Constants (runtime node interface)](https://js.pezkuwichain.app/docs/bizinikiwi/constants)
+
+## API Selection
+
+There are two flavours of the API provided, one allowing a standard interface via JavaScript Promises and the second provides an Observable wrapper using [RxJS](https://github.com/ReactiveX/rxjs). Depending on your use-case and familiarity, you can choose either (or even both) for your application.
+
+- [[ApiPromise]] All interface calls returns Promises, including the static `.create(...)`. Additionally any subscription method uses `(value) => {}` callbacks, returning the value as the subscription is updated.
+- [[ApiRx]] All interface calls return RxJS Observables, including the static `.create(...)`. In the same fashion subscription-based methods return long-running Observables that update with the latest values.
+
+## Dynamic by default
+
+Bizinikiwi (upon which Pezkuwi is built) uses on-chain WASM runtimes, allowing for upgradability. Each runtime defining the actual chain extrinsics (submitted transactions and block intrinsics) as well as available entries in the chain state. Due to this, the API endpoints for queries and transactions are dynamically populated from the running chain.
+
+Due to this dynamic nature, this API departs from traditional APIs which only has fixed endpoints, driving use by what is available by the runtime. As a start, this generic nature has a learning curve, although the provided documentation, examples and linked documentation tries to make that experience as seamless as possible.
+
+## Installation & import
+
+Installation -
+
+```
+npm install --save @pezkuwi/api
+```
+
+Subscribing to blocks via Promise-based API -
+
+```javascript
+import { ApiPromise } from 'https://deno.land/x/pezkuwi/api/mod.ts';
+
+const api = await ApiPromise.create();
+
+api.rpc.chain.subscribeNewHeads((header) => {
+  console.log(`Chain is at #${header.number}`);
+});
+```
+
+Subscribing to blocks via RxJS-based API -
+
+```javascript
+import { ApiRx } from 'https://deno.land/x/pezkuwi/api/mod.ts';
+
+const api = await ApiRx.create().toPromise();
+
+api.rpc.chain.subscribeNewHeads().subscribe((header) => {
+  console.log(`Chain is at #${header.number}`);
+});
+```
+
+## Registering custom types
+
+Additional types used by runtime modules can be added when a new instance of the API is created. This is necessary if the runtime modules use types which are not available in the base Bizinikiwi runtime.
+
+```javascript
+import { ApiPromise } from 'https://deno.land/x/pezkuwi/api/mod.ts';
+
+const api = await ApiPromise.create({
+  types: {
+    CustomTypesExample: {
+      "id": "u32",
+      "data": "Vec<u8>",
+      "deposit": "Balance",
+      "owner": "AccountId",
+      "application_expiry": "Moment",
+      "whitelisted": "bool",
+      "challenge_id": "u32"
+    }
+  }
+});
+```
+
+## Users
+
+Some of the users of the API (let us know if you are missing from the list), include -
+
+- [Pezkuwi-JS UI](https://github.com/pezkuwichain/pezkuwi-apps) A user-interface that allows you to make transactions, query the network or participate in actions on the network such as referendums and staking
+- [KodaDot](https://github.com/vue-pezkuwi/apps) ([twitter](https://twitter.com/KodaDot)) - Vue.js web wallet, governance dashboard and aspiring performance (lightweight) alternative to original apps, mobile-first.
+- [Polkabot](https://gitlab.com/Polkabot) Polkabot is a Matrix chatbot that keeps an eye on the Pezkuwi network. You can see Polkabot in action in https://matrix.to/#/#pezkuwi-network-status:matrix.org
+- [Polkawallet.io](https://polkawallet.io) and [Polkawallet (Github)](https://github.com/polkawallet-io/polkawallet-RN/) A mobile wallet for the Pezkuwi network to manage funds and make transactions, available on both Androind and iOS
+- [PolkaStats.io](https://polkastats.io), [PolkaStats frontend GitHub repository](https://github.com/Colm3na/polkastats-v2) and [PolkaStats backend GitHub repository](https://github.com/Colm3na/polkastats-backend-v2) Pezkuwi network statistics (currently Zagros and Alexander). Shows network information and staking details from validators and intentions.
+- [Pezkuwi API Server (GitHub)](https://github.com/SimplyVC/pezkuwi_api_server) A lightweight server for querying Pezkuwi nodes from any language, built primarily as a backend for [PANIC for Pezkuwi (GitHub)](https://github.com/SimplyVC/panic_pezkuwi/), a validator monitoring and alerting tool.
+- [Identity Registrar #1 from Chevdor on Zagros, Zagros and Pezkuwi](https://www.chevdor.com/tags/registrar/)

package/build-deno/augment.ts

@@ -0,0 +1,2 @@
+
+import 'https://deno.land/x/pezkuwi/api-augment/mod.ts';