@polkadot/rpc-augment 6.12.2-14

package/LICENSE

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                    http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+  "License" shall mean the terms and conditions for use, reproduction,
+  and distribution as defined by Sections 1 through 9 of this document.
+
+  "Licensor" shall mean the copyright owner or entity authorized by
+  the copyright owner that is granting the License.
+
+  "Legal Entity" shall mean the union of the acting entity and all
+  other entities that control, are controlled by, or are under common
+  control with that entity. For the purposes of this definition,
+  "control" means (i) the power, direct or indirect, to cause the
+  direction or management of such entity, whether by contract or
+  otherwise, or (ii) ownership of fifty percent (50%) or more of the
+  outstanding shares, or (iii) beneficial ownership of such entity.
+
+  "You" (or "Your") shall mean an individual or Legal Entity
+  exercising permissions granted by this License.
+
+  "Source" form shall mean the preferred form for making modifications,
+  including but not limited to software source code, documentation
+  source, and configuration files.
+
+  "Object" form shall mean any form resulting from mechanical
+  transformation or translation of a Source form, including but
+  not limited to compiled object code, generated documentation,
+  and conversions to other media types.
+
+  "Work" shall mean the work of authorship, whether in Source or
+  Object form, made available under the License, as indicated by a
+  copyright notice that is included in or attached to the work
+  (an example is provided in the Appendix below).
+
+  "Derivative Works" shall mean any work, whether in Source or Object
+  form, that is based on (or derived from) the Work and for which the
+  editorial revisions, annotations, elaborations, or other modifications
+  represent, as a whole, an original work of authorship. For the purposes
+  of this License, Derivative Works shall not include works that remain
+  separable from, or merely link (or bind by name) to the interfaces of,
+  the Work and Derivative Works thereof.
+
+  "Contribution" shall mean any work of authorship, including
+  the original version of the Work and any modifications or additions
+  to that Work or Derivative Works thereof, that is intentionally
+  submitted to Licensor for inclusion in the Work by the copyright owner
+  or by an individual or Legal Entity authorized to submit on behalf of
+  the copyright owner. For the purposes of this definition, "submitted"
+  means any form of electronic, verbal, or written communication sent
+  to the Licensor or its representatives, including but not limited to
+  communication on electronic mailing lists, source code control systems,
+  and issue tracking systems that are managed by, or on behalf of, the
+  Licensor for the purpose of discussing and improving the Work, but
+  excluding communication that is conspicuously marked or otherwise
+  designated in writing by the copyright owner as "Not a Contribution."
+
+  "Contributor" shall mean Licensor and any individual or Legal Entity
+  on behalf of whom a Contribution has been received by Licensor and
+  subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  copyright license to reproduce, prepare Derivative Works of,
+  publicly display, publicly perform, sublicense, and distribute the
+  Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  (except as stated in this section) patent license to make, have made,
+  use, offer to sell, sell, import, and otherwise transfer the Work,
+  where such license applies only to those patent claims licensable
+  by such Contributor that are necessarily infringed by their
+  Contribution(s) alone or by combination of their Contribution(s)
+  with the Work to which such Contribution(s) was submitted. If You
+  institute patent litigation against any entity (including a
+  cross-claim or counterclaim in a lawsuit) alleging that the Work
+  or a Contribution incorporated within the Work constitutes direct
+  or contributory patent infringement, then any patent licenses
+  granted to You under this License for that Work shall terminate
+  as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+  Work or Derivative Works thereof in any medium, with or without
+  modifications, and in Source or Object form, provided that You
+  meet the following conditions:
+
+  (a) You must give any other recipients of the Work or
+      Derivative Works a copy of this License; and
+
+  (b) You must cause any modified files to carry prominent notices
+      stating that You changed the files; and
+
+  (c) You must retain, in the Source form of any Derivative Works
+      that You distribute, all copyright, patent, trademark, and
+      attribution notices from the Source form of the Work,
+      excluding those notices that do not pertain to any part of
+      the Derivative Works; and
+
+  (d) If the Work includes a "NOTICE" text file as part of its
+      distribution, then any Derivative Works that You distribute must
+      include a readable copy of the attribution notices contained
+      within such NOTICE file, excluding those notices that do not
+      pertain to any part of the Derivative Works, in at least one
+      of the following places: within a NOTICE text file distributed
+      as part of the Derivative Works; within the Source form or
+      documentation, if provided along with the Derivative Works; or,
+      within a display generated by the Derivative Works, if and
+      wherever such third-party notices normally appear. The contents
+      of the NOTICE file are for informational purposes only and
+      do not modify the License. You may add Your own attribution
+      notices within Derivative Works that You distribute, alongside
+      or as an addendum to the NOTICE text from the Work, provided
+      that such additional attribution notices cannot be construed
+      as modifying the License.
+
+  You may add Your own copyright statement to Your modifications and
+  may provide additional or different license terms and conditions
+  for use, reproduction, or distribution of Your modifications, or
+  for any such Derivative Works as a whole, provided Your use,
+  reproduction, and distribution of the Work otherwise complies with
+  the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+  any Contribution intentionally submitted for inclusion in the Work
+  by You to the Licensor shall be under the terms and conditions of
+  this License, without any additional terms or conditions.
+  Notwithstanding the above, nothing herein shall supersede or modify
+  the terms of any separate license agreement you may have executed
+  with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+  names, trademarks, service marks, or product names of the Licensor,
+  except as required for reasonable and customary use in describing the
+  origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+  agreed to in writing, Licensor provides the Work (and each
+  Contributor provides its Contributions) on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied, including, without limitation, any warranties or conditions
+  of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+  PARTICULAR PURPOSE. You are solely responsible for determining the
+  appropriateness of using or redistributing the Work and assume any
+  risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+  whether in tort (including negligence), contract, or otherwise,
+  unless required by applicable law (such as deliberate and grossly
+  negligent acts) or agreed to in writing, shall any Contributor be
+  liable to You for damages, including any direct, indirect, special,
+  incidental, or consequential damages of any character arising as a
+  result of this License or out of the use or inability to use the
+  Work (including but not limited to damages for loss of goodwill,
+  work stoppage, computer failure or malfunction, or any and all
+  other commercial damages or losses), even if such Contributor
+  has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+  the Work or Derivative Works thereof, You may choose to offer,
+  and charge a fee for, acceptance of support, warranty, indemnity,
+  or other liability obligations and/or rights consistent with this
+  License. However, in accepting such obligations, You may act only
+  on Your own behalf and on Your sole responsibility, not on behalf
+  of any other Contributor, and only if You agree to indemnify,
+  defend, and hold each Contributor harmless for any liability
+  incurred by, or claims asserted against, such Contributor by reason
+  of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+  To apply the Apache License to your work, attach the following
+  boilerplate notice, with the fields enclosed by brackets "[]"
+  replaced with your own identifying information. (Don't include
+  the brackets!)  The text should be enclosed in the appropriate
+  comment syntax for the file format. We also recommend that a
+  file or class name and description of purpose be included on the
+  same "printed page" as the copyright notice for easier
+  identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,3 @@
+# @polkadot/api-augment
+
+Generated augmentation.

package/augment/index.cjs

@@ -0,0 +1,5 @@
+"use strict";
+
+require("@polkadot/types/augment");
+
+require("./rpc.cjs");

package/augment/index.d.ts

@@ -0,0 +1,2 @@
+import '@polkadot/types/augment';
+import './rpc';

package/augment/index.js

@@ -0,0 +1,4 @@
+// Copyright 2017-2021 @polkadot/rpc-augment authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import '@polkadot/types/augment';
+import "./rpc.js";

package/augment/rpc.cjs

@@ -0,0 +1 @@
+"use strict";

package/augment/rpc.d.ts

@@ -0,0 +1,614 @@
+declare module '@polkadot/rpc-augment/rpc' {
+    import type { AugmentedRpc } from '@polkadot/rpc-augment/types';
+    import type { Bytes, HashMap, Json, Metadata, Null, Option, StorageKey, Text, U256, U64, Vec, bool, u32, u64 } from '@polkadot/types';
+    import type { ExtrinsicOrHash, ExtrinsicStatus } from '@polkadot/types/interfaces/author';
+    import type { EpochAuthorship } from '@polkadot/types/interfaces/babe';
+    import type { BeefySignedCommitment } from '@polkadot/types/interfaces/beefy';
+    import type { BlockHash } from '@polkadot/types/interfaces/chain';
+    import type { PrefixedStorageKey } from '@polkadot/types/interfaces/childstate';
+    import type { AuthorityId } from '@polkadot/types/interfaces/consensus';
+    import type { ContractCallRequest, ContractExecResult, ContractInstantiateResult, InstantiateRequest } from '@polkadot/types/interfaces/contracts';
+    import type { CreatedBlock } from '@polkadot/types/interfaces/engine';
+    import type { EthAccount, EthCallRequest, EthFilter, EthFilterChanges, EthLog, EthReceipt, EthRichBlock, EthSubKind, EthSubParams, EthSyncStatus, EthTransaction, EthTransactionRequest, EthWork } from '@polkadot/types/interfaces/eth';
+    import type { Extrinsic } from '@polkadot/types/interfaces/extrinsics';
+    import type { EncodedFinalityProofs, JustificationNotification, ReportedRoundStates } from '@polkadot/types/interfaces/grandpa';
+    import type { MmrLeafProof } from '@polkadot/types/interfaces/mmr';
+    import type { StorageKind } from '@polkadot/types/interfaces/offchain';
+    import type { FeeDetails, RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment';
+    import type { RpcMethods } from '@polkadot/types/interfaces/rpc';
+    import type { AccountId, BlockNumber, H160, H256, H64, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime';
+    import type { ReadProof, RuntimeVersion, TraceBlockResponse } from '@polkadot/types/interfaces/state';
+    import type { ApplyExtrinsicResult, ChainProperties, ChainType, Health, NetworkState, NodeRole, PeerInfo, SyncState } from '@polkadot/types/interfaces/system';
+    import type { AnyNumber, Codec, IExtrinsic, Observable } from '@polkadot/types/types';
+    interface RpcInterface {
+        author: {
+            /**
+             * Returns true if the keystore has private keys for the given public key and key type.
+             **/
+            hasKey: AugmentedRpc<(publicKey: Bytes | string | Uint8Array, keyType: Text | string) => Observable<bool>>;
+            /**
+             * Returns true if the keystore has private keys for the given session public keys.
+             **/
+            hasSessionKeys: AugmentedRpc<(sessionKeys: Bytes | string | Uint8Array) => Observable<bool>>;
+            /**
+             * Insert a key into the keystore.
+             **/
+            insertKey: AugmentedRpc<(keyType: Text | string, suri: Text | string, publicKey: Bytes | string | Uint8Array) => Observable<Bytes>>;
+            /**
+             * Returns all pending extrinsics, potentially grouped by sender
+             **/
+            pendingExtrinsics: AugmentedRpc<() => Observable<Vec<Extrinsic>>>;
+            /**
+             * Remove given extrinsic from the pool and temporarily ban it to prevent reimporting
+             **/
+            removeExtrinsic: AugmentedRpc<(bytesOrHash: Vec<ExtrinsicOrHash> | (ExtrinsicOrHash | {
+                Hash: any;
+            } | {
+                Extrinsic: any;
+            } | string | Uint8Array)[]) => Observable<Vec<Hash>>>;
+            /**
+             * Generate new session keys and returns the corresponding public keys
+             **/
+            rotateKeys: AugmentedRpc<() => Observable<Bytes>>;
+            /**
+             * Submit and subscribe to watch an extrinsic until unsubscribed
+             **/
+            submitAndWatchExtrinsic: AugmentedRpc<(extrinsic: IExtrinsic) => Observable<ExtrinsicStatus>>;
+            /**
+             * Submit a fully formatted extrinsic for block inclusion
+             **/
+            submitExtrinsic: AugmentedRpc<(extrinsic: IExtrinsic) => Observable<Hash>>;
+        };
+        babe: {
+            /**
+             * Returns data about which slots (primary or secondary) can be claimed in the current epoch with the keys in the keystore
+             **/
+            epochAuthorship: AugmentedRpc<() => Observable<HashMap<AuthorityId, EpochAuthorship>>>;
+        };
+        beefy: {
+            /**
+             * Returns the block most recently finalized by BEEFY, alongside side its justification.
+             **/
+            subscribeJustifications: AugmentedRpc<() => Observable<BeefySignedCommitment>>;
+        };
+        chain: {
+            /**
+             * Get header and body of a relay chain block
+             **/
+            getBlock: AugmentedRpc<(hash?: BlockHash | string | Uint8Array) => Observable<SignedBlock>>;
+            /**
+             * Get the block hash for a specific block
+             **/
+            getBlockHash: AugmentedRpc<(blockNumber?: BlockNumber | AnyNumber | Uint8Array) => Observable<BlockHash>>;
+            /**
+             * Get hash of the last finalized block in the canon chain
+             **/
+            getFinalizedHead: AugmentedRpc<() => Observable<BlockHash>>;
+            /**
+             * Retrieves the header for a specific block
+             **/
+            getHeader: AugmentedRpc<(hash?: BlockHash | string | Uint8Array) => Observable<Header>>;
+            /**
+             * Retrieves the newest header via subscription
+             **/
+            subscribeAllHeads: AugmentedRpc<() => Observable<Header>>;
+            /**
+             * Retrieves the best finalized header via subscription
+             **/
+            subscribeFinalizedHeads: AugmentedRpc<() => Observable<Header>>;
+            /**
+             * Retrieves the best header via subscription
+             **/
+            subscribeNewHeads: AugmentedRpc<() => Observable<Header>>;
+        };
+        childstate: {
+            /**
+             * Returns the keys with prefix from a child storage, leave empty to get all the keys
+             **/
+            getKeys: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, prefix: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
+            /**
+             * Returns the keys with prefix from a child storage with pagination support
+             **/
+            getKeysPaged: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, prefix: StorageKey | string | Uint8Array | any, count: u32 | AnyNumber | Uint8Array, startKey?: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
+            /**
+             * Returns a child storage entry at a specific block state
+             **/
+            getStorage: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Option<StorageData>>>;
+            /**
+             * Returns child storage entries for multiple keys at a specific block state
+             **/
+            getStorageEntries: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: Hash | string | Uint8Array) => Observable<Vec<Option<StorageData>>>>;
+            /**
+             * Returns the hash of a child storage entry at a block state
+             **/
+            getStorageHash: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Option<Hash>>>;
+            /**
+             * Returns the size of a child storage entry at a block state
+             **/
+            getStorageSize: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Option<u64>>>;
+        };
+        contracts: {
+            /**
+             * Executes a call to a contract
+             **/
+            call: AugmentedRpc<(callRequest: ContractCallRequest | {
+                origin?: any;
+                dest?: any;
+                value?: any;
+                gasLimit?: any;
+                inputData?: any;
+            } | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ContractExecResult>>;
+            /**
+             * Returns the value under a specified storage key in a contract
+             **/
+            getStorage: AugmentedRpc<(address: AccountId | string | Uint8Array, key: H256 | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<Option<Bytes>>>;
+            /**
+             * Instantiate a new contract
+             **/
+            instantiate: AugmentedRpc<(request: InstantiateRequest | {
+                origin?: any;
+                value?: any;
+                gasLimit?: any;
+                code?: any;
+                data?: any;
+                salt?: any;
+            } | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ContractInstantiateResult>>;
+            /**
+             * Returns the projected time a given contract will be able to sustain paying its rent
+             **/
+            rentProjection: AugmentedRpc<(address: AccountId | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<Option<BlockNumber>>>;
+        };
+        engine: {
+            /**
+             * Instructs the manual-seal authorship task to create a new block
+             **/
+            createBlock: AugmentedRpc<(createEmpty: bool | boolean | Uint8Array, finalize: bool | boolean | Uint8Array, parentHash?: BlockHash | string | Uint8Array) => Observable<CreatedBlock>>;
+            /**
+             * Instructs the manual-seal authorship task to finalize a block
+             **/
+            finalizeBlock: AugmentedRpc<(hash: BlockHash | string | Uint8Array, justification?: Justification) => Observable<bool>>;
+        };
+        eth: {
+            /**
+             * Returns accounts list.
+             **/
+            accounts: AugmentedRpc<() => Observable<Vec<H160>>>;
+            /**
+             * Returns the blockNumber
+             **/
+            blockNumber: AugmentedRpc<() => Observable<U256>>;
+            /**
+             * Call contract, returning the output data.
+             **/
+            call: AugmentedRpc<(request: EthCallRequest | {
+                from?: any;
+                to?: any;
+                gasPrice?: any;
+                gas?: any;
+                value?: any;
+                data?: any;
+                nonce?: any;
+            } | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<Bytes>>;
+            /**
+             * Returns the chain ID used for transaction signing at the current best block. None is returned if not available.
+             **/
+            chainId: AugmentedRpc<() => Observable<U64>>;
+            /**
+             * Returns block author.
+             **/
+            coinbase: AugmentedRpc<() => Observable<H160>>;
+            /**
+             * Estimate gas needed for execution of given contract.
+             **/
+            estimateGas: AugmentedRpc<(request: EthCallRequest | {
+                from?: any;
+                to?: any;
+                gasPrice?: any;
+                gas?: any;
+                value?: any;
+                data?: any;
+                nonce?: any;
+            } | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
+            /**
+             * Returns current gas price.
+             **/
+            gasPrice: AugmentedRpc<() => Observable<U256>>;
+            /**
+             * Returns balance of the given account.
+             **/
+            getBalance: AugmentedRpc<(address: H160 | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
+            /**
+             * Returns block with given hash.
+             **/
+            getBlockByHash: AugmentedRpc<(hash: H256 | string | Uint8Array, full: bool | boolean | Uint8Array) => Observable<Option<EthRichBlock>>>;
+            /**
+             * Returns block with given number.
+             **/
+            getBlockByNumber: AugmentedRpc<(block: BlockNumber | AnyNumber | Uint8Array, full: bool | boolean | Uint8Array) => Observable<Option<EthRichBlock>>>;
+            /**
+             * Returns the number of transactions in a block with given hash.
+             **/
+            getBlockTransactionCountByHash: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<U256>>;
+            /**
+             * Returns the number of transactions in a block with given block number.
+             **/
+            getBlockTransactionCountByNumber: AugmentedRpc<(block: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
+            /**
+             * Returns the code at given address at given time (block number).
+             **/
+            getCode: AugmentedRpc<(address: H160 | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<Bytes>>;
+            /**
+             * Returns filter changes since last poll.
+             **/
+            getFilterChanges: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array) => Observable<EthFilterChanges>>;
+            /**
+             * Returns all logs matching given filter (in a range 'from' - 'to').
+             **/
+            getFilterLogs: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array) => Observable<Vec<EthLog>>>;
+            /**
+             * Returns logs matching given filter object.
+             **/
+            getLogs: AugmentedRpc<(filter: EthFilter | {
+                fromBlock?: any;
+                toBlock?: any;
+                blockHash?: any;
+                address?: any;
+                topics?: any;
+            } | string | Uint8Array) => Observable<Vec<EthLog>>>;
+            /**
+             * Returns proof for account and storage.
+             **/
+            getProof: AugmentedRpc<(address: H160 | string | Uint8Array, storageKeys: Vec<H256> | (H256 | string | Uint8Array)[], number: BlockNumber | AnyNumber | Uint8Array) => Observable<EthAccount>>;
+            /**
+             * Returns content of the storage at given address.
+             **/
+            getStorageAt: AugmentedRpc<(address: H160 | string | Uint8Array, index: U256 | AnyNumber | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<H256>>;
+            /**
+             * Returns transaction at given block hash and index.
+             **/
+            getTransactionByBlockHashAndIndex: AugmentedRpc<(hash: H256 | string | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthTransaction>>;
+            /**
+             * Returns transaction by given block number and index.
+             **/
+            getTransactionByBlockNumberAndIndex: AugmentedRpc<(number: BlockNumber | AnyNumber | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthTransaction>>;
+            /**
+             * Get transaction by its hash.
+             **/
+            getTransactionByHash: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<EthTransaction>>;
+            /**
+             * Returns the number of transactions sent from given address at given time (block number).
+             **/
+            getTransactionCount: AugmentedRpc<(hash: H256 | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
+            /**
+             * Returns transaction receipt by transaction hash.
+             **/
+            getTransactionReceipt: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<EthReceipt>>;
+            /**
+             * Returns an uncles at given block and index.
+             **/
+            getUncleByBlockHashAndIndex: AugmentedRpc<(hash: H256 | string | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthRichBlock>>;
+            /**
+             * Returns an uncles at given block and index.
+             **/
+            getUncleByBlockNumberAndIndex: AugmentedRpc<(number: BlockNumber | AnyNumber | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthRichBlock>>;
+            /**
+             * Returns the number of uncles in a block with given hash.
+             **/
+            getUncleCountByBlockHash: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<U256>>;
+            /**
+             * Returns the number of uncles in a block with given block number.
+             **/
+            getUncleCountByBlockNumber: AugmentedRpc<(number: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
+            /**
+             * Returns the hash of the current block, the seedHash, and the boundary condition to be met.
+             **/
+            getWork: AugmentedRpc<() => Observable<EthWork>>;
+            /**
+             * Returns the number of hashes per second that the node is mining with.
+             **/
+            hashrate: AugmentedRpc<() => Observable<U256>>;
+            /**
+             * Returns true if client is actively mining new blocks.
+             **/
+            mining: AugmentedRpc<() => Observable<bool>>;
+            /**
+             * Returns id of new block filter.
+             **/
+            newBlockFilter: AugmentedRpc<() => Observable<U256>>;
+            /**
+             * Returns id of new filter.
+             **/
+            newFilter: AugmentedRpc<(filter: EthFilter | {
+                fromBlock?: any;
+                toBlock?: any;
+                blockHash?: any;
+                address?: any;
+                topics?: any;
+            } | string | Uint8Array) => Observable<U256>>;
+            /**
+             * Returns id of new block filter.
+             **/
+            newPendingTransactionFilter: AugmentedRpc<() => Observable<U256>>;
+            /**
+             * Returns protocol version encoded as a string (quotes are necessary).
+             **/
+            protocolVersion: AugmentedRpc<() => Observable<u64>>;
+            /**
+             * Sends signed transaction, returning its hash.
+             **/
+            sendRawTransaction: AugmentedRpc<(bytes: Bytes | string | Uint8Array) => Observable<H256>>;
+            /**
+             * Sends transaction; will block waiting for signer to return the transaction hash
+             **/
+            sendTransaction: AugmentedRpc<(tx: EthTransactionRequest | {
+                from?: any;
+                to?: any;
+                gasPrice?: any;
+                gas?: any;
+                value?: any;
+                data?: any;
+                nonce?: any;
+            } | string | Uint8Array) => Observable<H256>>;
+            /**
+             * Used for submitting mining hashrate.
+             **/
+            submitHashrate: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array, hash: H256 | string | Uint8Array) => Observable<bool>>;
+            /**
+             * Used for submitting a proof-of-work solution.
+             **/
+            submitWork: AugmentedRpc<(nonce: H64 | string | Uint8Array, headerHash: H256 | string | Uint8Array, mixDigest: H256 | string | Uint8Array) => Observable<bool>>;
+            /**
+             * Subscribe to Eth subscription.
+             **/
+            subscribe: AugmentedRpc<(kind: EthSubKind | 'newHeads' | 'logs' | 'newPendingTransactions' | 'syncing' | number | Uint8Array, params?: EthSubParams | {
+                None: any;
+            } | {
+                Logs: any;
+            } | string | Uint8Array) => Observable<Null>>;
+            /**
+             * Returns an object with data about the sync status or false.
+             **/
+            syncing: AugmentedRpc<() => Observable<EthSyncStatus>>;
+            /**
+             * Uninstalls filter.
+             **/
+            uninstallFilter: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array) => Observable<bool>>;
+        };
+        grandpa: {
+            /**
+             * Prove finality for the range (begin; end] hash.
+             **/
+            proveFinality: AugmentedRpc<(begin: BlockHash | string | Uint8Array, end: BlockHash | string | Uint8Array, authoritiesSetId?: u64 | AnyNumber | Uint8Array) => Observable<Option<EncodedFinalityProofs>>>;
+            /**
+             * Returns the state of the current best round state as well as the ongoing background rounds
+             **/
+            roundState: AugmentedRpc<() => Observable<ReportedRoundStates>>;
+            /**
+             * Subscribes to grandpa justifications
+             **/
+            subscribeJustifications: AugmentedRpc<() => Observable<JustificationNotification>>;
+        };
+        mmr: {
+            /**
+             * Generate MMR proof for given leaf index.
+             **/
+            generateProof: AugmentedRpc<(leafIndex: u64 | AnyNumber | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<MmrLeafProof>>;
+        };
+        net: {
+            /**
+             * Returns true if client is actively listening for network connections. Otherwise false.
+             **/
+            listening: AugmentedRpc<() => Observable<bool>>;
+            /**
+             * Returns number of peers connected to node.
+             **/
+            peerCount: AugmentedRpc<() => Observable<Text>>;
+            /**
+             * Returns protocol version.
+             **/
+            version: AugmentedRpc<() => Observable<Text>>;
+        };
+        offchain: {
+            /**
+             * Get offchain local storage under given key and prefix
+             **/
+            localStorageGet: AugmentedRpc<(kind: StorageKind | 'PERSISTENT' | 'LOCAL' | number | Uint8Array, key: Bytes | string | Uint8Array) => Observable<Option<Bytes>>>;
+            /**
+             * Set offchain local storage under given key and prefix
+             **/
+            localStorageSet: AugmentedRpc<(kind: StorageKind | 'PERSISTENT' | 'LOCAL' | number | Uint8Array, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => Observable<Null>>;
+        };
+        payment: {
+            /**
+             * Query the detailed fee of a given encoded extrinsic
+             **/
+            queryFeeDetails: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<FeeDetails>>;
+            /**
+             * Retrieves the fee information for an encoded extrinsic
+             **/
+            queryInfo: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<RuntimeDispatchInfo>>;
+        };
+        rpc: {
+            /**
+             * Retrieves the list of RPC methods that are exposed by the node
+             **/
+            methods: AugmentedRpc<() => Observable<RpcMethods>>;
+        };
+        state: {
+            /**
+             * Perform a call to a builtin on the chain
+             **/
+            call: AugmentedRpc<(method: Text | string, data: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<Bytes>>;
+            /**
+             * Retrieves the keys with prefix of a specific child storage
+             **/
+            getChildKeys: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
+            /**
+             * Returns proof of storage for child key entries at a specific block state.
+             **/
+            getChildReadProof: AugmentedRpc<(childStorageKey: PrefixedStorageKey | string | Uint8Array, keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: BlockHash | string | Uint8Array) => Observable<ReadProof>>;
+            /**
+             * Retrieves the child storage for a key
+             **/
+            getChildStorage: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<StorageData>>;
+            /**
+             * Retrieves the child storage hash
+             **/
+            getChildStorageHash: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Hash>>;
+            /**
+             * Retrieves the child storage size
+             **/
+            getChildStorageSize: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<u64>>;
+            /**
+             * Retrieves the keys with a certain prefix
+             **/
+            getKeys: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
+            /**
+             * Returns the keys with prefix with pagination support.
+             **/
+            getKeysPaged: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, count: u32 | AnyNumber | Uint8Array, startKey?: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
+            /**
+             * Returns the runtime metadata
+             **/
+            getMetadata: AugmentedRpc<(at?: BlockHash | string | Uint8Array) => Observable<Metadata>>;
+            /**
+             * Returns the keys with prefix, leave empty to get all the keys (deprecated: Use getKeysPaged)
+             **/
+            getPairs: AugmentedRpc<(prefix: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<KeyValue>>>;
+            /**
+             * Returns proof of storage entries at a specific block state
+             **/
+            getReadProof: AugmentedRpc<(keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: BlockHash | string | Uint8Array) => Observable<ReadProof>>;
+            /**
+             * Get the runtime version
+             **/
+            getRuntimeVersion: AugmentedRpc<(at?: BlockHash | string | Uint8Array) => Observable<RuntimeVersion>>;
+            /**
+             * Retrieves the storage for a key
+             **/
+            getStorage: AugmentedRpc<(<T = Codec>(key: StorageKey | string | Uint8Array | any, block?: Hash | Uint8Array | string) => Observable<T>)>;
+            /**
+             * Retrieves the storage hash
+             **/
+            getStorageHash: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Hash>>;
+            /**
+             * Retrieves the storage size
+             **/
+            getStorageSize: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<u64>>;
+            /**
+             * Query historical storage entries (by key) starting from a start block
+             **/
+            queryStorage: AugmentedRpc<(<T = Codec[]>(keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], fromBlock?: Hash | Uint8Array | string, toBlock?: Hash | Uint8Array | string) => Observable<[Hash, T][]>)>;
+            /**
+             * Query storage entries (by key) starting at block hash given as the second parameter
+             **/
+            queryStorageAt: AugmentedRpc<(<T = Codec[]>(keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: Hash | Uint8Array | string) => Observable<T>)>;
+            /**
+             * Retrieves the runtime version via subscription
+             **/
+            subscribeRuntimeVersion: AugmentedRpc<() => Observable<RuntimeVersion>>;
+            /**
+             * Subscribes to storage changes for the provided keys
+             **/
+            subscribeStorage: AugmentedRpc<(<T = Codec[]>(keys?: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[]) => Observable<T>)>;
+            /**
+             * Provides a way to trace the re-execution of a single block
+             **/
+            traceBlock: AugmentedRpc<(block: Hash | string | Uint8Array, targets: Option<Text> | null | object | string | Uint8Array, storageKeys: Option<Text> | null | object | string | Uint8Array, methods: Option<Text> | null | object | string | Uint8Array) => Observable<TraceBlockResponse>>;
+        };
+        syncstate: {
+            /**
+             * Returns the json-serialized chainspec running the node, with a sync state.
+             **/
+            genSyncSpec: AugmentedRpc<(raw: bool | boolean | Uint8Array) => Observable<Json>>;
+        };
+        system: {
+            /**
+             * Retrieves the next accountIndex as available on the node
+             **/
+            accountNextIndex: AugmentedRpc<(accountId: AccountId | string | Uint8Array) => Observable<Index>>;
+            /**
+             * Adds the supplied directives to the current log filter
+             **/
+            addLogFilter: AugmentedRpc<(directives: Text | string) => Observable<Null>>;
+            /**
+             * Adds a reserved peer
+             **/
+            addReservedPeer: AugmentedRpc<(peer: Text | string) => Observable<Text>>;
+            /**
+             * Retrieves the chain
+             **/
+            chain: AugmentedRpc<() => Observable<Text>>;
+            /**
+             * Retrieves the chain type
+             **/
+            chainType: AugmentedRpc<() => Observable<ChainType>>;
+            /**
+             * Dry run an extrinsic at a given block
+             **/
+            dryRun: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ApplyExtrinsicResult>>;
+            /**
+             * Return health status of the node
+             **/
+            health: AugmentedRpc<() => Observable<Health>>;
+            /**
+             * The addresses include a trailing /p2p/ with the local PeerId, and are thus suitable to be passed to addReservedPeer or as a bootnode address for example
+             **/
+            localListenAddresses: AugmentedRpc<() => Observable<Vec<Text>>>;
+            /**
+             * Returns the base58-encoded PeerId of the node
+             **/
+            localPeerId: AugmentedRpc<() => Observable<Text>>;
+            /**
+             * Retrieves the node name
+             **/
+            name: AugmentedRpc<() => Observable<Text>>;
+            /**
+             * Returns current state of the network
+             **/
+            networkState: AugmentedRpc<() => Observable<NetworkState>>;
+            /**
+             * Returns the roles the node is running as
+             **/
+            nodeRoles: AugmentedRpc<() => Observable<Vec<NodeRole>>>;
+            /**
+             * Returns the currently connected peers
+             **/
+            peers: AugmentedRpc<() => Observable<Vec<PeerInfo>>>;
+            /**
+             * Get a custom set of properties as a JSON object, defined in the chain spec
+             **/
+            properties: AugmentedRpc<() => Observable<ChainProperties>>;
+            /**
+             * Remove a reserved peer
+             **/
+            removeReservedPeer: AugmentedRpc<(peerId: Text | string) => Observable<Text>>;
+            /**
+             * Returns the list of reserved peers
+             **/
+            reservedPeers: AugmentedRpc<() => Observable<Vec<Text>>>;
+            /**
+             * Resets the log filter to Substrate defaults
+             **/
+            resetLogFilter: AugmentedRpc<() => Observable<Null>>;
+            /**
+             * Returns the state of the syncing of the node
+             **/
+            syncState: AugmentedRpc<() => Observable<SyncState>>;
+            /**
+             * Retrieves the version of the node
+             **/
+            version: AugmentedRpc<() => Observable<Text>>;
+        };
+        web3: {
+            /**
+             * Returns current client version.
+             **/
+            clientVersion: AugmentedRpc<() => Observable<Text>>;
+            /**
+             * Returns sha3 of the given data
+             **/
+            sha3: AugmentedRpc<(data: Bytes | string | Uint8Array) => Observable<H256>>;
+        };
+    }
+}

package/bundle.cjs

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  packageInfo: true
+};
+Object.defineProperty(exports, "packageInfo", {
+  enumerable: true,
+  get: function () {
+    return _packageInfo.packageInfo;
+  }
+});
+
+require("@polkadot/rpc-augment/augment");
+
+var _packageInfo = require("./packageInfo.cjs");
+
+var _rpc = require("@polkadot/rpc-augment/rpc");
+
+Object.keys(_rpc).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _rpc[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _rpc[key];
+    }
+  });
+});

package/bundle.d.ts

@@ -0,0 +1,3 @@
+import '@polkadot/rpc-augment/augment';
+export { packageInfo } from './packageInfo';
+export * from '@polkadot/rpc-augment/rpc';

package/bundle.js

@@ -0,0 +1,6 @@
+// Copyright 2017-2021 @polkadot/rpc-augment authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// trigger in the same way as we do externally
+import '@polkadot/rpc-augment/augment';
+export { packageInfo } from "./packageInfo.js";
+export * from '@polkadot/rpc-augment/rpc';

package/detectPackage.cjs

@@ -0,0 +1,11 @@
+"use strict";
+
+var _packageInfo = require("@polkadot/types/packageInfo");
+
+var _util = require("@polkadot/util");
+
+var _packageInfo2 = require("./packageInfo.cjs");
+
+// Copyright 2017-2021 @polkadot/rpc-augment authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+(0, _util.detectPackage)(_packageInfo2.packageInfo, typeof __dirname !== 'undefined' && __dirname, [_packageInfo.packageInfo]);

package/detectPackage.d.ts

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

package/detectPackage.js

@@ -0,0 +1,6 @@
+// Copyright 2017-2021 @polkadot/rpc-augment authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { packageInfo as typesInfo } from '@polkadot/types/packageInfo';
+import { detectPackage } from '@polkadot/util';
+import { packageInfo } from "./packageInfo.js";
+detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname, [typesInfo]);

package/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+require("./detectPackage.cjs");
+
+var _bundle = require("./bundle.cjs");
+
+Object.keys(_bundle).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bundle[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _bundle[key];
+    }
+  });
+});

package/index.d.ts

@@ -0,0 +1,2 @@
+import './detectPackage';
+export * from './bundle';

package/index.js

@@ -0,0 +1,4 @@
+// Copyright 2017-2021 @polkadot/rpc-augment authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import "./detectPackage.js";
+export * from "./bundle.js";

package/package.json

@@ -0,0 +1,69 @@
+{
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/polkadot-js/api/issues",
+  "contributors": [],
+  "description": "RPC generated augmentation",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "homepage": "https://github.com/polkadot-js/api/tree/master/packages/rpc-augment#readme",
+  "license": "Apache-2.0",
+  "maintainers": [],
+  "name": "@polkadot/rpc-augment",
+  "repository": {
+    "directory": "packages/rpc-augment",
+    "type": "git",
+    "url": "https://github.com/polkadot-js/api.git"
+  },
+  "sideEffects": [
+    "./detectPackage.js",
+    "./detectPackage.cjs"
+  ],
+  "type": "module",
+  "version": "6.12.2-14",
+  "main": "index.js",
+  "dependencies": {
+    "@babel/runtime": "^7.16.5",
+    "@polkadot/types": "6.12.2-14",
+    "rxjs": "^7.4.0"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.cjs",
+      "default": "./index.js"
+    },
+    "./augment": {
+      "require": "./augment/index.cjs",
+      "default": "./augment/index.js"
+    },
+    "./augment/index.d.ts": "./augment/index.d.ts",
+    "./augment/rpc": {
+      "require": "./augment/rpc.cjs",
+      "default": "./augment/rpc.js"
+    },
+    "./augment/rpc.d.ts": "./augment/rpc.d.ts",
+    "./bundle": {
+      "require": "./bundle.cjs",
+      "default": "./bundle.js"
+    },
+    "./bundle.d.ts": "./bundle.d.ts",
+    "./detectPackage": {
+      "require": "./detectPackage.cjs",
+      "default": "./detectPackage.js"
+    },
+    "./detectPackage.d.ts": "./detectPackage.d.ts",
+    "./index.d.ts": "./index.d.ts",
+    "./package.json": "./package.json",
+    "./packageInfo": {
+      "require": "./packageInfo.cjs",
+      "default": "./packageInfo.js"
+    },
+    "./packageInfo.d.ts": "./packageInfo.d.ts",
+    "./README.md": "./README.md",
+    "./types": {
+      "require": "./types.cjs",
+      "default": "./types.js"
+    },
+    "./types.d.ts": "./types.d.ts"
+  }
+}

package/packageInfo.cjs

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.packageInfo = void 0;
+// Copyright 2017-2021 @polkadot/rpc-augment authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// Auto-generated by @polkadot/dev, do not edit
+const packageInfo = {
+  name: '@polkadot/rpc-augment',
+  version: '6.12.2-14'
+};
+exports.packageInfo = packageInfo;

package/packageInfo.d.ts

@@ -0,0 +1,4 @@
+export declare const packageInfo: {
+    name: string;
+    version: string;
+};

package/packageInfo.js

@@ -0,0 +1,7 @@
+// Copyright 2017-2021 @polkadot/rpc-augment authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// Auto-generated by @polkadot/dev, do not edit
+export const packageInfo = {
+  name: '@polkadot/rpc-augment',
+  version: '6.12.2-14'
+};

package/types.cjs

@@ -0,0 +1 @@
+"use strict";

package/types.d.ts

@@ -0,0 +1,11 @@
+import type { Observable } from 'rxjs';
+import type { AnyFunction, Codec, DefinitionRpc } from '@polkadot/types/types';
+export interface RpcInterfaceMethod {
+    <T extends Codec>(...params: unknown[]): Observable<T>;
+    raw(...params: unknown[]): Observable<unknown>;
+    meta: DefinitionRpc;
+}
+export declare type AugmentedRpc<F extends AnyFunction> = F & {
+    raw: <T>(...params: Parameters<F>) => Observable<T>;
+    meta: DefinitionRpc;
+};

package/types.js

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