quantus/api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Parsing for metadata v14 (#3759)

Browse Source 
* Adjust

* Better, need a BoundedVec solution...

* Composites

* Storage optional types

* Better... not perfect

* v14 tests passing

* Always perform asLatest

* Keep portable registry seperate

* Cleanup derived types

* Cleanups

* Adjust

* Cleanups

* Pass wraps

* Rename types (PortableRegistry) -> lookup

* Back on-track...

* SiLookup strings

* Allow building

* unsafe create on registry

* createTypeUnsafe typing

* Adjust

* Fix bool check

* Remove WrappedConstructor

* Additional

* Additional cleanups

* On-demand even type creation

* Rework

* Adjust

* Revert createClass to master (with adjustments)

* Running through v14

* Registry from master

* Run against v14

* Adjust

* Adjust

* Adjust generation (non-complete)

* Adjust

* Definition from metadata (round 1)

* Some linting fixes

* v13

* Adjust

* Dedupe

* Some linting

* Additional linting (md generation, not all)

* md additional

* calls update

* Additional linting

* Cleanups

* Remove extra arg

* Remove unneeded assert

* Revert < 12 index adjustments

* Cleanups

* v13 compat types

* Some tests

* Registry revert

* Additional test fixes

* Adjust sorting

* Adjust tests with lookups

* CodeClimate cleanups

* Additional tests

* Compat with prev-generation args

* Error & events compat args

* Fix Error/Event metadata creation

* Fix lookup circular

* Registry types

* Adjust

* Adjust lookup generation

* Short-circuit full type (with lookupIndex)

* Defaults for type expansion

* Tuple with extra spaces removed

* Fill in generated types

* Checks

* Adjust generation

* Adjust tests

* Adjust

* Adjust type encoding

* Adjust

* Use registry for name generation

* Update v13 lookup generation

* Adjust looup with typeDef (optional)

* Format lookup definitions

* Start with TS interface generation

* Adjust

* Adjust

* Adjust

* Don't short-cisrcuit type evaluation

* Adjust

* Correct plain imports

* Adjust

* Don't remove already-set lookupName

* Bytes

* Cleanups

* Adjust with unused

* Embed non-named structs

* Enum without name throws error

* Case-sensitivity on path duplication

* s/lookupNameOrig/lookupNameRoot/

* Don't export Lookup* type interfaces

* Shortcut lookup

* Adjust

* Revert api/Decorate

* Adjust import name generation

* Don't clobber root lookups

* Root exports

* Remove duplicated fields creation

* Adjust less-important name parts

* Cleanups & imports

* Adjust with correct imports

* Storage optionality

* Rebuild, fix (some) tests

* Extract identity BitFlags

* Additional cleanups

* Adjust

* No IdentityFields override

* v13 for extrinsic test

* Dedupe getUniqTypes

* Simplify?

* Adjust

* Update sorting

* Adjust expansion

* Dedupe

* Strip generics, sub-part * matching

* Name matching

* Align

* Adjust set matching

* hex/json split

* naming

* v13 for extrinsic injection test

* Adjust test signature

* Dedupe tests

* Adjust

* Update import

* augment @polkadot/types/lookup

* Sort import names

* Handle BitSequence in PortableRegistry

* Use Kusama-dev v14 metadata

* Merge bitSequence support

* Polkadot/Substrate split

* Template formatting

* Hobbling along

* Adjust

* Recode subs

* Fix circular in dual fashion

* Adjust

* Also generate Substrate

* Exclude Substrate types from Polkadot

* Remove duplicate phantoms

* Cleanup lookup typegen

* Additional

* Extract names with params (as applicable)

* Ensure path is always available

* renames

* Metadata v14 only has combined Map

* v14 Map conversion de-duped

* Substrate Map conversion

* v13 tests

* Apply suggestions from code review

* Housekeeping

* v14 bump

* NMap -> Map (& others removed)

* Adjust generation

* Decorate linting

* Tuple & non-tuple types

* hashers check

* Condense

* Additional asTuple check

* Consistent pre-v14 Map handling

* Fix metadata tests

* Fix (some) tests

* Fix test expectations

* Fail create early

* Additional fixes

* Additional

* Movement

* Remove CodecArg

* Dump it

* Apply param expansion

* Remove only

* Allow no-args to StorageKey

* linting

* multi fixes

* Map adjustments

* Rebuild

* Rebuild

* Rebuild

* Latest

* Bump metadata

* Rewrite

* Fix lookup formatting

* Rebuild after merge

* Latest substrate v14

* Rebuild

* Rebuild (+ no enum trailing ,)

* trigger

* Fix JSON checks

* Remove unneeded check

* Bump Kusama/Polkadot

* Dedupe testUtil

* Metadata v14
This commit is contained in:
Jaco
2021-09-15 19:46:48 +03:00
committed by GitHub
parent 88e5b26532
commit 22aafbdd4c
120 changed files with 21171 additions and 10491 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/api-derive/src/index.spec.ts
+2 -1
View File
@@ -78,7 +78,8 @@ describe('derive', (): void => {
}
},
provider: new MockProvider(registry),
registry
registry,
throwOnConnect: true
});
beforeAll((done): void => {
packages/api/src/augment/consts.ts
+91 -97
View File
@@ -1,17 +1,11 @@
// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
/* eslint-disable */
import type { Vec, bool, u16, u32, u64 } from '@polkadot/types';
import type { Codec } from '@polkadot/types/types';
import type { Schedule } from '@polkadot/types/interfaces/contracts';
import type { Balance, BalanceOf, BlockNumber, LockIdentifier, Moment, PalletId, Perbill, Percent, Permill, RuntimeDbWeight, TransactionPriority, Weight } from '@polkadot/types/interfaces/runtime';
import type { SessionIndex } from '@polkadot/types/interfaces/session';
import type { EraIndex } from '@polkadot/types/interfaces/staking';
import type { RuntimeVersion } from '@polkadot/types/interfaces/state';
import type { WeightToFeeCoefficient } from '@polkadot/types/interfaces/support';
import type { BlockLength, BlockWeights } from '@polkadot/types/interfaces/system';
import type { DepositBalanceOf } from '@polkadot/types/interfaces/uniques';
import type { ApiTypes } from '@polkadot/api/types';
import type { U8aFixed, Vec, bool, u128, u16, u32, u64 } from '@polkadot/types';
import type { Perbill, Percent, Permill } from '@polkadot/types/interfaces/runtime';
import type { FrameSupportPalletId, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, PalletContractsSchedule, SpVersionRuntimeVersion } from '@polkadot/types/lookup';
import type { Codec } from '@polkadot/types/types';
declare module '@polkadot/api/types/consts' {
export interface AugmentedConsts<ApiType> {
@@ -19,20 +13,20 @@ declare module '@polkadot/api/types/consts' {
/**
* The amount of funds that must be reserved when creating a new approval.
**/
approvalDeposit: DepositBalanceOf & AugmentedConst<ApiType>;
approvalDeposit: u128 & AugmentedConst<ApiType>;
/**
* The basic amount of funds that must be reserved for an asset.
**/
assetDeposit: DepositBalanceOf & AugmentedConst<ApiType>;
assetDeposit: u128 & AugmentedConst<ApiType>;
/**
* The basic amount of funds that must be reserved when adding metadata to your asset.
**/
metadataDepositBase: DepositBalanceOf & AugmentedConst<ApiType>;
metadataDepositBase: u128 & AugmentedConst<ApiType>;
/**
* The additional funds that must be reserved for the number of bytes you store in your
* metadata.
**/
metadataDepositPerByte: DepositBalanceOf & AugmentedConst<ApiType>;
metadataDepositPerByte: u128 & AugmentedConst<ApiType>;
/**
* The maximum length of a name or symbol stored on-chain.
**/
@@ -48,7 +42,7 @@ declare module '@polkadot/api/types/consts' {
* This means that we will deal with uncle-parents that are
* `UncleGenerations + 1` before `now`.
**/
uncleGenerations: BlockNumber & AugmentedConst<ApiType>;
uncleGenerations: u32 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -68,7 +62,7 @@ declare module '@polkadot/api/types/consts' {
* duration and the security parameter `c` (where `1 - c` represents
* the probability of a slot being empty).
**/
expectedBlockTime: Moment & AugmentedConst<ApiType>;
expectedBlockTime: u64 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -78,7 +72,7 @@ declare module '@polkadot/api/types/consts' {
/**
* The minimum amount required to keep an account open.
**/
existentialDeposit: Balance & AugmentedConst<ApiType>;
existentialDeposit: u128 & AugmentedConst<ApiType>;
/**
* The maximum number of locks that should exist on an account.
* Not strictly enforced, but used for weight estimation.
@@ -101,23 +95,23 @@ declare module '@polkadot/api/types/consts' {
/**
* The amount held on deposit for placing a bounty proposal.
**/
bountyDepositBase: BalanceOf & AugmentedConst<ApiType>;
bountyDepositBase: u128 & AugmentedConst<ApiType>;
/**
* The delay period for which a bounty beneficiary need to wait before claim the payout.
**/
bountyDepositPayoutDelay: BlockNumber & AugmentedConst<ApiType>;
bountyDepositPayoutDelay: u32 & AugmentedConst<ApiType>;
/**
* Bounty duration in blocks.
**/
bountyUpdatePeriod: BlockNumber & AugmentedConst<ApiType>;
bountyUpdatePeriod: u32 & AugmentedConst<ApiType>;
/**
* Minimum value for a bounty.
**/
bountyValueMinimum: BalanceOf & AugmentedConst<ApiType>;
bountyValueMinimum: u128 & AugmentedConst<ApiType>;
/**
* The amount held on deposit per byte within bounty description.
**/
dataDepositPerByte: BalanceOf & AugmentedConst<ApiType>;
dataDepositPerByte: u128 & AugmentedConst<ApiType>;
/**
* Maximum acceptable reason length.
**/
@@ -134,7 +128,7 @@ declare module '@polkadot/api/types/consts' {
* The minimum balance for a contract's account can be queried using
* [`Pallet::subsistence_threshold`].
**/
contractDeposit: BalanceOf & AugmentedConst<ApiType>;
contractDeposit: u128 & AugmentedConst<ApiType>;
/**
* The maximum number of tries that can be queued for deletion.
**/
@@ -142,11 +136,11 @@ declare module '@polkadot/api/types/consts' {
/**
* The maximum amount of weight that can be consumed per block for lazy trie removal.
**/
deletionWeightLimit: Weight & AugmentedConst<ApiType>;
deletionWeightLimit: u64 & AugmentedConst<ApiType>;
/**
* Cost schedule and limits.
**/
schedule: Schedule & AugmentedConst<ApiType>;
schedule: PalletContractsSchedule & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -156,7 +150,7 @@ declare module '@polkadot/api/types/consts' {
/**
* Period in blocks where an external proposal may not be re-submitted after being vetoed.
**/
cooloffPeriod: BlockNumber & AugmentedConst<ApiType>;
cooloffPeriod: u32 & AugmentedConst<ApiType>;
/**
* The period between a proposal being approved and enacted.
*
@@ -164,11 +158,11 @@ declare module '@polkadot/api/types/consts' {
* voting stakers have an opportunity to remove themselves from the system in the case
* where they are on the losing side of a vote.
**/
enactmentPeriod: BlockNumber & AugmentedConst<ApiType>;
enactmentPeriod: u32 & AugmentedConst<ApiType>;
/**
* Minimum voting period allowed for a fast-track referendum.
**/
fastTrackVotingPeriod: BlockNumber & AugmentedConst<ApiType>;
fastTrackVotingPeriod: u32 & AugmentedConst<ApiType>;
/**
* Indicator for whether an emergency origin is even allowed to happen. Some chains may
* want to set this permanently to `false`, others may want to condition it on things such
@@ -178,7 +172,7 @@ declare module '@polkadot/api/types/consts' {
/**
* How often (in blocks) new public referenda are launched.
**/
launchPeriod: BlockNumber & AugmentedConst<ApiType>;
launchPeriod: u32 & AugmentedConst<ApiType>;
/**
* The maximum number of public proposals that can exist at any time.
**/
@@ -193,22 +187,22 @@ declare module '@polkadot/api/types/consts' {
/**
* The minimum amount to be used as a deposit for a public referendum proposal.
**/
minimumDeposit: BalanceOf & AugmentedConst<ApiType>;
minimumDeposit: u128 & AugmentedConst<ApiType>;
/**
* The amount of balance that must be deposited per byte of preimage stored.
**/
preimageByteDeposit: BalanceOf & AugmentedConst<ApiType>;
preimageByteDeposit: u128 & AugmentedConst<ApiType>;
/**
* The minimum period of vote locking.
*
* It should be no shorter than enactment period to ensure that in the case of an approval,
* those successful voters are locked into the consequences that their votes entail.
**/
voteLockingPeriod: BlockNumber & AugmentedConst<ApiType>;
voteLockingPeriod: u32 & AugmentedConst<ApiType>;
/**
* How often (in blocks) to check for new votes.
**/
votingPeriod: BlockNumber & AugmentedConst<ApiType>;
votingPeriod: u32 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -228,30 +222,30 @@ declare module '@polkadot/api/types/consts' {
* The miner will ensure that the total weight of the unsigned solution will not exceed
* this value, based on [`WeightInfo::submit_unsigned`].
**/
minerMaxWeight: Weight & AugmentedConst<ApiType>;
minerMaxWeight: u64 & AugmentedConst<ApiType>;
/**
* The priority of the unsigned transaction submitted in the unsigned-phase
**/
minerTxPriority: TransactionPriority & AugmentedConst<ApiType>;
minerTxPriority: u64 & AugmentedConst<ApiType>;
/**
* The repeat threshold of the offchain worker.
*
* For example, if it is 5, that means that at least 5 blocks will elapse between attempts
* to submit the worker's solution.
**/
offchainRepeat: BlockNumber & AugmentedConst<ApiType>;
offchainRepeat: u32 & AugmentedConst<ApiType>;
/**
* Base deposit for a signed solution.
**/
signedDepositBase: BalanceOf & AugmentedConst<ApiType>;
signedDepositBase: u128 & AugmentedConst<ApiType>;
/**
* Per-byte deposit for a signed solution.
**/
signedDepositByte: BalanceOf & AugmentedConst<ApiType>;
signedDepositByte: u128 & AugmentedConst<ApiType>;
/**
* Per-weight deposit for a signed solution.
**/
signedDepositWeight: BalanceOf & AugmentedConst<ApiType>;
signedDepositWeight: u128 & AugmentedConst<ApiType>;
/**
* Maximum number of signed submissions that can be queued.
*
@@ -267,15 +261,15 @@ declare module '@polkadot/api/types/consts' {
*
* This should probably be similar to [`Config::MinerMaxWeight`].
**/
signedMaxWeight: Weight & AugmentedConst<ApiType>;
signedMaxWeight: u64 & AugmentedConst<ApiType>;
/**
* Duration of the signed phase.
**/
signedPhase: BlockNumber & AugmentedConst<ApiType>;
signedPhase: u32 & AugmentedConst<ApiType>;
/**
* Base reward for a signed solution
**/
signedRewardBase: BalanceOf & AugmentedConst<ApiType>;
signedRewardBase: u128 & AugmentedConst<ApiType>;
/**
* The minimum amount of improvement to the solution score that defines a solution as
* "better" (in any phase).
@@ -284,7 +278,7 @@ declare module '@polkadot/api/types/consts' {
/**
* Duration of the unsigned phase.
**/
unsignedPhase: BlockNumber & AugmentedConst<ApiType>;
unsignedPhase: u32 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -294,7 +288,7 @@ declare module '@polkadot/api/types/consts' {
/**
* How much should be locked up in order to submit one's candidacy.
**/
candidacyBond: BalanceOf & AugmentedConst<ApiType>;
candidacyBond: u128 & AugmentedConst<ApiType>;
/**
* Number of members to elect.
**/
@@ -306,24 +300,24 @@ declare module '@polkadot/api/types/consts' {
/**
* Identifier for the elections-phragmen pallet's lock
**/
palletId: LockIdentifier & AugmentedConst<ApiType>;
palletId: U8aFixed & AugmentedConst<ApiType>;
/**
* How long each seat is kept. This defines the next block number at which an election
* round will happen. If set to zero, no elections are ever triggered and the module will
* be in passive mode.
**/
termDuration: BlockNumber & AugmentedConst<ApiType>;
termDuration: u32 & AugmentedConst<ApiType>;
/**
* Base deposit associated with voting.
*
* This should be sensibly high to economically ensure the pallet cannot be attacked by
* creating a gigantic number of votes.
**/
votingBondBase: BalanceOf & AugmentedConst<ApiType>;
votingBondBase: u128 & AugmentedConst<ApiType>;
/**
* The amount of bond that need to be locked for each vote (32 bytes).
**/
votingBondFactor: BalanceOf & AugmentedConst<ApiType>;
votingBondFactor: u128 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -340,7 +334,7 @@ declare module '@polkadot/api/types/consts' {
* The issuance to ignore. This is subtracted from the `Currency`'s `total_issuance` to get
* the issuance by which we inflate or deflate the gilt.
**/
ignoredIssuance: BalanceOf & AugmentedConst<ApiType>;
ignoredIssuance: u128 & AugmentedConst<ApiType>;
/**
* The number of blocks between consecutive attempts to issue more gilts in an effort to
* get to the target amount to be frozen.
@@ -348,7 +342,7 @@ declare module '@polkadot/api/types/consts' {
* A larger value results in fewer storage hits each block, but a slower period to get to
* the target.
**/
intakePeriod: BlockNumber & AugmentedConst<ApiType>;
intakePeriod: u32 & AugmentedConst<ApiType>;
/**
* The maximum amount of bids that can be turned into issued gilts each block. A larger
* value here means less of the block available for transactions should there be a glut of
@@ -367,12 +361,12 @@ declare module '@polkadot/api/types/consts' {
* It should be at least big enough to ensure that there is no possible storage spam attack
* or queue-filling attack.
**/
minFreeze: BalanceOf & AugmentedConst<ApiType>;
minFreeze: u128 & AugmentedConst<ApiType>;
/**
* The base period for the duration queues. This is the common multiple across all
* supported freezing durations that can be bid upon.
**/
period: BlockNumber & AugmentedConst<ApiType>;
period: u32 & AugmentedConst<ApiType>;
/**
* Number of duration queues in total. This sets the maximum duration supported, which is
* this value multiplied by `Period`.
@@ -387,11 +381,11 @@ declare module '@polkadot/api/types/consts' {
/**
* The amount held on deposit for a registered identity
**/
basicDeposit: BalanceOf & AugmentedConst<ApiType>;
basicDeposit: u128 & AugmentedConst<ApiType>;
/**
* The amount held on deposit per additional field for a registered identity.
**/
fieldDeposit: BalanceOf & AugmentedConst<ApiType>;
fieldDeposit: u128 & AugmentedConst<ApiType>;
/**
* Maximum number of additional fields that may be stored in an ID. Needed to bound the I/O
* required to access an identity, but can be pretty high.
@@ -411,7 +405,7 @@ declare module '@polkadot/api/types/consts' {
* that one storage item's value will increase by the size of an account ID, and there will
* be another trie item whose value is the size of an account ID plus 32 bytes.
**/
subAccountDeposit: BalanceOf & AugmentedConst<ApiType>;
subAccountDeposit: u128 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -424,7 +418,7 @@ declare module '@polkadot/api/types/consts' {
* This is exposed so that it can be tuned for particular runtime, when
* multiple pallets send unsigned transactions.
**/
unsignedPriority: TransactionPriority & AugmentedConst<ApiType>;
unsignedPriority: u64 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -434,7 +428,7 @@ declare module '@polkadot/api/types/consts' {
/**
* The deposit needed for reserving an index.
**/
deposit: BalanceOf & AugmentedConst<ApiType>;
deposit: u128 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -454,7 +448,7 @@ declare module '@polkadot/api/types/consts' {
/**
* The Lottery's pallet id
**/
palletId: PalletId & AugmentedConst<ApiType>;
palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -469,13 +463,13 @@ declare module '@polkadot/api/types/consts' {
* `4 + sizeof((BlockNumber, Balance, AccountId))` bytes and whose key size is
* `32 + sizeof(AccountId)` bytes.
**/
depositBase: BalanceOf & AugmentedConst<ApiType>;
depositBase: u128 & AugmentedConst<ApiType>;
/**
* The amount of currency needed per unit threshold when creating a multisig execution.
*
* This is held for adding 32 bytes more into a pre-existing storage value.
**/
depositFactor: BalanceOf & AugmentedConst<ApiType>;
depositFactor: u128 & AugmentedConst<ApiType>;
/**
* The maximum amount of signatories allowed in the multisig.
**/
@@ -492,14 +486,14 @@ declare module '@polkadot/api/types/consts' {
* This is held when a new storage item holding a `Balance` is created (typically 16
* bytes).
**/
announcementDepositBase: BalanceOf & AugmentedConst<ApiType>;
announcementDepositBase: u128 & AugmentedConst<ApiType>;
/**
* The amount of currency needed per announcement made.
*
* This is held for adding an `AccountId`, `Hash` and `BlockNumber` (typically 68 bytes)
* into a pre-existing storage value.
**/
announcementDepositFactor: BalanceOf & AugmentedConst<ApiType>;
announcementDepositFactor: u128 & AugmentedConst<ApiType>;
/**
* The maximum amount of time-delayed announcements that are allowed to be pending.
**/
@@ -514,7 +508,7 @@ declare module '@polkadot/api/types/consts' {
* This is held for an additional storage item whose value size is
* `sizeof(Balance)` bytes and whose key size is `sizeof(AccountId)` bytes.
**/
proxyDepositBase: BalanceOf & AugmentedConst<ApiType>;
proxyDepositBase: u128 & AugmentedConst<ApiType>;
/**
* The amount of currency needed per proxy added.
*
@@ -522,7 +516,7 @@ declare module '@polkadot/api/types/consts' {
* pre-existing storage value. Thus, when configuring `ProxyDepositFactor` one should take
* into account `32 + proxy_type.encode().len()` bytes of data.
**/
proxyDepositFactor: BalanceOf & AugmentedConst<ApiType>;
proxyDepositFactor: u128 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -535,7 +529,7 @@ declare module '@polkadot/api/types/consts' {
* This is held for an additional storage item whose value size is
* `2 + sizeof(BlockNumber, Balance)` bytes.
**/
configDepositBase: BalanceOf & AugmentedConst<ApiType>;
configDepositBase: u128 & AugmentedConst<ApiType>;
/**
* The amount of currency needed per additional user when creating a recovery
* configuration.
@@ -543,7 +537,7 @@ declare module '@polkadot/api/types/consts' {
* This is held for adding `sizeof(AccountId)` bytes more into a pre-existing storage
* value.
**/
friendDepositFactor: BalanceOf & AugmentedConst<ApiType>;
friendDepositFactor: u128 & AugmentedConst<ApiType>;
/**
* The maximum amount of friends allowed in a recovery configuration.
**/
@@ -557,7 +551,7 @@ declare module '@polkadot/api/types/consts' {
* `sizeof(BlockNumber, Balance + T * AccountId)` bytes. Where T is a configurable
* threshold.
**/
recoveryDeposit: BalanceOf & AugmentedConst<ApiType>;
recoveryDeposit: u128 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -568,7 +562,7 @@ declare module '@polkadot/api/types/consts' {
* The maximum weight that may be scheduled per block for any dispatchables of less
* priority than `schedule::HARD_DEADLINE`.
**/
maximumWeight: Weight & AugmentedConst<ApiType>;
maximumWeight: u64 & AugmentedConst<ApiType>;
/**
* The maximum number of scheduled calls in the queue for a single block.
* Not strictly enforced, but used for weight estimation.
@@ -583,11 +577,11 @@ declare module '@polkadot/api/types/consts' {
/**
* The minimum amount of a deposit required for a bid to be made.
**/
candidateDeposit: BalanceOf & AugmentedConst<ApiType>;
candidateDeposit: u128 & AugmentedConst<ApiType>;
/**
* The number of blocks between membership challenges.
**/
challengePeriod: BlockNumber & AugmentedConst<ApiType>;
challengePeriod: u32 & AugmentedConst<ApiType>;
/**
* Maximum candidate intake per round.
**/
@@ -600,20 +594,20 @@ declare module '@polkadot/api/types/consts' {
/**
* The societies's module id
**/
palletId: PalletId & AugmentedConst<ApiType>;
palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
/**
* The amount of incentive paid within each period. Doesn't include VoterTip.
**/
periodSpend: BalanceOf & AugmentedConst<ApiType>;
periodSpend: u128 & AugmentedConst<ApiType>;
/**
* The number of blocks between candidate/membership rotation periods.
**/
rotationPeriod: BlockNumber & AugmentedConst<ApiType>;
rotationPeriod: u32 & AugmentedConst<ApiType>;
/**
* The amount of the unpaid reward that gets deducted in the case that either a skeptic
* doesn't vote or someone votes in the wrong way.
**/
wrongSideDeduction: BalanceOf & AugmentedConst<ApiType>;
wrongSideDeduction: u128 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -623,7 +617,7 @@ declare module '@polkadot/api/types/consts' {
/**
* Number of eras that staked funds must remain bonded for.
**/
bondingDuration: EraIndex & AugmentedConst<ApiType>;
bondingDuration: u32 & AugmentedConst<ApiType>;
maxNominations: u32 & AugmentedConst<ApiType>;
/**
* The maximum number of nominators rewarded for each validator.
@@ -635,14 +629,14 @@ declare module '@polkadot/api/types/consts' {
/**
* Number of sessions per era.
**/
sessionsPerEra: SessionIndex & AugmentedConst<ApiType>;
sessionsPerEra: u32 & AugmentedConst<ApiType>;
/**
* Number of eras that slashes are deferred by, after computation.
*
* This should be less than the bonding duration. Set to 0 if slashes
* should be applied immediately, without opportunity for intervention.
**/
slashDeferDuration: EraIndex & AugmentedConst<ApiType>;
slashDeferDuration: u32 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -652,19 +646,19 @@ declare module '@polkadot/api/types/consts' {
/**
* Maximum number of block number to block hash mappings to keep (oldest pruned first).
**/
blockHashCount: BlockNumber & AugmentedConst<ApiType>;
blockHashCount: u32 & AugmentedConst<ApiType>;
/**
* The maximum length of a block (in bytes).
**/
blockLength: BlockLength & AugmentedConst<ApiType>;
blockLength: FrameSystemLimitsBlockLength & AugmentedConst<ApiType>;
/**
* Block & extrinsics weights: base values and limits.
**/
blockWeights: BlockWeights & AugmentedConst<ApiType>;
blockWeights: FrameSystemLimitsBlockWeights & AugmentedConst<ApiType>;
/**
* The weight of runtime database operations the runtime can invoke.
**/
dbWeight: RuntimeDbWeight & AugmentedConst<ApiType>;
dbWeight: FrameSupportWeightsRuntimeDbWeight & AugmentedConst<ApiType>;
/**
* The designated SS85 prefix of this chain.
*
@@ -676,7 +670,7 @@ declare module '@polkadot/api/types/consts' {
/**
* Get the chain's current version.
**/
version: RuntimeVersion & AugmentedConst<ApiType>;
version: SpVersionRuntimeVersion & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -689,7 +683,7 @@ declare module '@polkadot/api/types/consts' {
* generally work with this to determine a sensible block time. e.g. For Aura, it will be
* double this period on default settings.
**/
minimumPeriod: Moment & AugmentedConst<ApiType>;
minimumPeriod: u64 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -699,7 +693,7 @@ declare module '@polkadot/api/types/consts' {
/**
* The amount held on deposit per byte within the tip report reason or bounty description.
**/
dataDepositPerByte: BalanceOf & AugmentedConst<ApiType>;
dataDepositPerByte: u128 & AugmentedConst<ApiType>;
/**
* Maximum acceptable reason length.
**/
@@ -707,7 +701,7 @@ declare module '@polkadot/api/types/consts' {
/**
* The period for which a tip remains open after is has achieved threshold tippers.
**/
tipCountdown: BlockNumber & AugmentedConst<ApiType>;
tipCountdown: u32 & AugmentedConst<ApiType>;
/**
* The percent of the final tip which goes to the original reporter of the tip.
**/
@@ -715,7 +709,7 @@ declare module '@polkadot/api/types/consts' {
/**
* The amount held on deposit for placing a tip report.
**/
tipReportDepositBase: BalanceOf & AugmentedConst<ApiType>;
tipReportDepositBase: u128 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -725,11 +719,11 @@ declare module '@polkadot/api/types/consts' {
/**
* The fee to be paid for making a transaction; the per-byte portion.
**/
transactionByteFee: BalanceOf & AugmentedConst<ApiType>;
transactionByteFee: u128 & AugmentedConst<ApiType>;
/**
* The polynomial that is applied in order to derive fee from weight.
**/
weightToFee: Vec<WeightToFeeCoefficient> & AugmentedConst<ApiType>;
weightToFee: Vec<FrameSupportWeightsWeightToFeeCoefficient> & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -747,7 +741,7 @@ declare module '@polkadot/api/types/consts' {
/**
* The treasury's pallet id, used for deriving its sovereign account ID.
**/
palletId: PalletId & AugmentedConst<ApiType>;
palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
/**
* Fraction of a proposal's value that should be bonded in order to place the proposal.
* An accepted proposal gets these back. A rejected proposal does not.
@@ -756,11 +750,11 @@ declare module '@polkadot/api/types/consts' {
/**
* Minimum amount of funds that should be placed in a deposit for making a proposal.
**/
proposalBondMinimum: BalanceOf & AugmentedConst<ApiType>;
proposalBondMinimum: u128 & AugmentedConst<ApiType>;
/**
* Period between successive spends.
**/
spendPeriod: BlockNumber & AugmentedConst<ApiType>;
spendPeriod: u32 & AugmentedConst<ApiType>;
/**
* Generic const
**/
@@ -770,20 +764,20 @@ declare module '@polkadot/api/types/consts' {
/**
* The basic amount of funds that must be reserved when adding an attribute to an asset.
**/
attributeDepositBase: DepositBalanceOf & AugmentedConst<ApiType>;
attributeDepositBase: u128 & AugmentedConst<ApiType>;
/**
* The basic amount of funds that must be reserved for an asset class.
**/
classDeposit: DepositBalanceOf & AugmentedConst<ApiType>;
classDeposit: u128 & AugmentedConst<ApiType>;
/**
* The additional funds that must be reserved for the number of bytes store in metadata,
* either "normal" metadata or attribute metadata.
**/
depositPerByte: DepositBalanceOf & AugmentedConst<ApiType>;
depositPerByte: u128 & AugmentedConst<ApiType>;
/**
* The basic amount of funds that must be reserved for an asset instance.
**/
instanceDeposit: DepositBalanceOf & AugmentedConst<ApiType>;
instanceDeposit: u128 & AugmentedConst<ApiType>;
/**
* The maximum length of an attribute key.
**/
@@ -791,7 +785,7 @@ declare module '@polkadot/api/types/consts' {
/**
* The basic amount of funds that must be reserved when adding metadata to your asset.
**/
metadataDepositBase: DepositBalanceOf & AugmentedConst<ApiType>;
metadataDepositBase: u128 & AugmentedConst<ApiType>;
/**
* The maximum length of data stored on-chain.
**/
@@ -820,7 +814,7 @@ declare module '@polkadot/api/types/consts' {
/**
* The minimum amount transferred to call `vested_transfer`.
**/
minVestedTransfer: BalanceOf & AugmentedConst<ApiType>;
minVestedTransfer: u128 & AugmentedConst<ApiType>;
/**
* Generic const
**/
packages/api/src/augment/events.ts
+193 -211
View File
File diff suppressed because it is too large Load Diff
packages/api/src/augment/query.ts
+194 -220
View File
File diff suppressed because it is too large Load Diff
packages/api/src/augment/rpc.ts
+1 -1
View File
@@ -2,7 +2,6 @@
/* eslint-disable */
import type { Bytes, HashMap, Json, Metadata, Null, Option, StorageKey, Text, U256, U64, Vec, bool, u32, u64 } from '@polkadot/types';
import type { AnyNumber, Codec, IExtrinsic, Observable } from '@polkadot/types/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';
@@ -21,6 +20,7 @@ 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';
declare module '@polkadot/rpc-core/types.jsonrpc' {
export interface RpcInterface {
packages/api/src/augment/tx.ts
+217 -233
View File
File diff suppressed because it is too large Load Diff
packages/api/src/base/Decorate.ts
+18 -26
View File
@@ -360,7 +360,9 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
: this._rpcCore.state.queryStorageAt)(
calls.map((arg: QueryableStorageMultiArg<ApiType>) =>
Array.isArray(arg)
? [arg[0].creator, ...arg.slice(1)]
? arg[0].creator.meta.type.asMap.hashers.length === 1
? [arg[0].creator, arg.slice(1)]
: [arg[0].creator, ...arg.slice(1)]
: [arg.creator])));
}
@@ -436,18 +438,10 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
key.method === creator.method;
decorated.key = (...args: unknown[]): string =>
u8aToHex(compactStripLength(creator(
creator.meta.type.isPlain
? undefined
: creator.meta.type.isMap
? args[0]
: creator.meta.type.isDoubleMap
? [args[0], args[1]]
: args
))[1]);
u8aToHex(compactStripLength(creator(...args))[1]);
decorated.keyPrefix = (...keys: unknown[]): string =>
u8aToHex(creator.keyPrefix(...keys));
decorated.keyPrefix = (...args: unknown[]): string =>
u8aToHex(creator.keyPrefix(...args));
decorated.range = decorateMethod((range: [Hash, Hash?], ...args: unknown[]): Observable<[Hash, Codec][]> =>
this._decorateStorageRange(decorated, args, range));
@@ -458,9 +452,8 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
decorated.sizeAt = decorateMethod((hash: Hash | Uint8Array | string, ...args: unknown[]): Observable<u64> =>
this._rpcCore.state.getStorageSize(getArgs(args), hash));
// FIXME NMap support
// .keys() & .entries() only available on map types
if (creator.iterKey && (creator.meta.type.isMap || creator.meta.type.isDoubleMap || creator.meta.type.isNMap)) {
if (creator.iterKey && creator.meta.type.isMap) {
decorated.entries = decorateMethod(
memo(this.#instanceId, (...args: unknown[]): Observable<[StorageKey, Codec][]> =>
this._retrieveMapEntries(creator, null, args)));
@@ -486,10 +479,13 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
this._retrieveMapKeysPaged(creator, opts)));
}
if (this.supportMulti) {
if (this.supportMulti && creator.meta.type.isMap) {
// When using double map storage function, user need to pass double map key as an array
decorated.multi = decorateMethod((args: (unknown | unknown[])[]): Observable<Codec[]> =>
this._retrieveMulti(args.map((arg) => [creator, arg])));
decorated.multi = decorateMethod((args: unknown[]): Observable<Codec[]> =>
creator.meta.type.asMap.hashers.length === 1
? this._retrieveMulti(args.map((a) => [creator, [a]]))
: this._retrieveMulti(args.map((a) => [creator, a as unknown[]]))
);
}
/* eslint-enable @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment */
@@ -520,11 +516,7 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
u8aToHex(compactStripLength(creator(
creator.meta.type.isPlain
? undefined
: creator.meta.type.isMap
? args[0]
: creator.meta.type.isDoubleMap
? [args[0], args[1]]
: args
: args
))[1]);
decorated.keyPrefix = (...keys: unknown[]): string =>
@@ -535,7 +527,7 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
// FIXME NMap support
// .keys() & .entries() only available on map types
if (creator.iterKey && (creator.meta.type.isMap || creator.meta.type.isDoubleMap)) {
if (creator.iterKey && creator.meta.type.isMap) {
decorated.entries = decorateMethod(
memo(this.#instanceId, (...args: unknown[]): Observable<[StorageKey, Codec][]> =>
this._retrieveMapEntries(creator, blockHash, args)));
@@ -579,7 +571,7 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
}
// retrieve a set of values for a specific set of keys - here we chunk the keys into PAGE_SIZE sizes
private _retrieveMulti (keys: [StorageEntry, unknown | unknown[]][]): Observable<Codec[]> {
private _retrieveMulti (keys: [StorageEntry, unknown[]][]): Observable<Codec[]> {
if (!keys.length) {
return of([]);
}
@@ -596,7 +588,7 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
}
private _retrieveMapKeys ({ iterKey, meta, method, section }: StorageEntry, at: Hash | Uint8Array | string | null, args: unknown[]): Observable<StorageKey[]> {
assert(iterKey && (meta.type.isMap || meta.type.isDoubleMap || meta.type.isNMap), 'keys can only be retrieved on maps, linked maps and double maps');
assert(iterKey && meta.type.isMap, 'keys can only be retrieved on maps');
const headKey = iterKey(...args).toHex();
const startSubject = new BehaviorSubject<string>(headKey);
@@ -620,7 +612,7 @@ export abstract class Decorate<ApiType extends ApiTypes> extends Events {
}
private _retrieveMapKeysPaged ({ iterKey, meta, method, section }: StorageEntry, opts: PaginationOptions): Observable<StorageKey[]> {
assert(iterKey && (meta.type.isMap || meta.type.isDoubleMap || meta.type.isNMap), 'keys can only be retrieved on maps, linked maps and double maps');
assert(iterKey && meta.type.isMap, 'keys can only be retrieved on maps');
const headKey = iterKey(...opts.args).toHex();
packages/api/src/promise/index.spec.ts
+8 -14
View File
@@ -39,7 +39,7 @@ describe('ApiPromise', (): void => {
};
const signer = new SingleAccountSigner(registry, aliceEd);
const api = await ApiPromise.create({ provider, registry, signer });
const api = await ApiPromise.create({ provider, registry, signer, throwOnConnect: true });
const transfer = api.tx.balances.transfer(keyring.getPair('0xe659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e').address, 321564789876512345n);
return { api, transfer: await transfer.signAsync(aliceEd.address, {}) };
@@ -59,7 +59,7 @@ describe('ApiPromise', (): void => {
const rpcData = await provider.send<string>('state_getMetadata', []);
const genesisHash = registry.createType('Hash', await provider.send('chain_getBlockHash', [])).toHex();
const specVersion = 0;
const api = await ApiPromise.create({ metadata: { [`${genesisHash}-${specVersion}`]: rpcData }, provider, registry });
const api = await ApiPromise.create({ metadata: { [`${genesisHash}-${specVersion}`]: rpcData }, provider, registry, throwOnConnect: true });
expect(api.genesisHash).toBeDefined();
expect(api.runtimeMetadata).toBeDefined();
@@ -74,7 +74,7 @@ describe('ApiPromise', (): void => {
it('Create API instance without metadata and makes the runtime, rpc, state & extrinsics available', async (): Promise<void> => {
const metadata = {};
const api = await ApiPromise.create({ metadata, provider, registry });
const api = await ApiPromise.create({ metadata, provider, registry, throwOnConnect: true });
expect(api.genesisHash).toBeDefined();
expect(api.runtimeMetadata).toBeDefined();
@@ -98,17 +98,15 @@ describe('ApiPromise', (): void => {
}
}
const api = new ErrorApiPromise();
try {
await api.isReadyOrError;
const api = await ErrorApiPromise.create({ provider, throwOnConnect: true });
await api.disconnect();
fail('Expected an error but none occurred.');
} catch {
// Pass
}
await api.disconnect();
});
});
@@ -118,7 +116,7 @@ describe('ApiPromise', (): void => {
const SIG = '0x659effefbbe5ab4d7136ebb5084b959eb424e32b862307371be4721ac2c46334245af4f1476c36c5e5aff04396c2fdd2ce561ec90382821d4aa071b559b1db0f';
it('signs data using a specified keyring', async (): Promise<void> => {
const api = await ApiPromise.create({ provider, registry });
const api = await ApiPromise.create({ provider, registry, throwOnConnect: true });
const sig = await api.sign(aliceEd, TEST);
expect(sig).toEqual(SIG);
@@ -127,11 +125,7 @@ describe('ApiPromise', (): void => {
});
it('signs data using an external signer', async (): Promise<void> => {
const api = await ApiPromise.create({
provider,
registry,
signer: new SingleAccountSigner(registry, aliceEd)
});
const api = await ApiPromise.create({ provider, registry, signer: new SingleAccountSigner(registry, aliceEd), throwOnConnect: true });
const sig = await api.sign(ADDR, TEST);
expect(sig).toEqual(SIG);
packages/api/src/types/consts.ts
+2 -2
View File
@@ -1,7 +1,7 @@
// Copyright 2017-2021 @polkadot/api authors & contributors
// SPDX-License-Identifier: Apache-2.0
import type { ModuleConstantMetadataLatest } from '@polkadot/types/interfaces';
import type { PalletConstantMetadataLatest } from '@polkadot/types/interfaces';
import type { Codec } from '@polkadot/types/types';
import type { ApiTypes } from './base';
@@ -10,7 +10,7 @@ export interface AugmentedConsts<ApiType extends ApiTypes> { }
// eslint-disable-next-line @typescript-eslint/no-unused-vars
export interface AugmentedConst<ApiType extends ApiTypes> {
meta: ModuleConstantMetadataLatest;
meta: PalletConstantMetadataLatest;
}
export interface QueryableModuleConsts {
packages/api/src/util/validate.spec.ts
+15 -43
View File
@@ -1,8 +1,6 @@
// Copyright 2017-2019 @polkadot/api authors & contributors
// SPDX-License-Identifier: Apache-2.0
import type { Storage } from '@polkadot/types/metadata/decorate/types';
import { decorateStorage, Metadata, TypeRegistry } from '@polkadot/types';
import metaStatic from '@polkadot/types-support/metadata/static-substrate';
@@ -10,50 +8,46 @@ import { extractStorageArgs } from './validate';
describe('extractStorageArgs', (): void => {
const registry = new TypeRegistry();
let storage: Storage;
const metadata = new Metadata(registry, metaStatic);
beforeEach((): void => {
const metadata = new Metadata(registry, metaStatic);
registry.setMetadata(metadata);
storage = decorateStorage(registry, metadata.asLatest, metadata.version);
});
const storage = decorateStorage(registry, metadata.asLatest, metadata.version);
it('validates no-arg plain', (): void => {
expect(
extractStorageArgs(registry, storage.timestamp.now, [])
).toEqual([storage.timestamp.now]);
).toEqual([storage.timestamp.now, []]);
});
it('validates no-arg plain (with undefined, undefined)', (): void => {
expect(
extractStorageArgs(registry, storage.timestamp.now, [undefined, undefined])
).toEqual([storage.timestamp.now]);
).toEqual([storage.timestamp.now, []]);
});
it('validates no-arg plain (failing when there are args)', (): void => {
expect(
(): unknown => extractStorageArgs(registry, storage.timestamp.now, [123, 456])
() => extractStorageArgs(registry, storage.timestamp.now, [123, 456])
).toThrow('timestamp.now() does not take any arguments, 2 found');
});
it('validates map, 1 arg', (): void => {
expect(
extractStorageArgs(registry, storage.staking.payee, ['abc'])
).toEqual([storage.staking.payee, 'abc']);
).toEqual([storage.staking.payee, ['abc']]);
});
it('validates map, 1 arg (failing with no args)', (): void => {
expect(
(): any =>
extractStorageArgs(registry, storage.staking.payee, [])
).toThrow('staking.payee(AccountId) is a map, requiring 1 argument, 0 found');
() => extractStorageArgs(registry, storage.staking.payee, [])
).toThrow('staking.payee(AccountId32) is a map, requiring 1 arguments, 0 found');
});
it('validates map, 1 arg (failing with no args)', (): void => {
expect(
(): any =>
extractStorageArgs(registry, storage.staking.payee, ['abc', 'def'])
).toThrow('staking.payee(AccountId) is a map, requiring 1 argument, 2 found');
() => extractStorageArgs(registry, storage.staking.payee, ['abc', 'def'])
).toThrow('staking.payee(AccountId32) is a map, requiring 1 arguments, 2 found');
});
it('validates doublemap, 2 args', (): void => {
@@ -64,35 +58,13 @@ describe('extractStorageArgs', (): void => {
it('validates doublemap, 2 args (failing with no args)', (): void => {
expect(
(): any =>
extractStorageArgs(registry, storage.staking.erasStakers, [])
).toThrow('staking.erasStakers(EraIndex, AccountId) is a double map, requiring 2 arguments, 0 found');
() => extractStorageArgs(registry, storage.staking.erasStakers, [])
).toThrow('staking.erasStakers(u32, AccountId32) is a map, requiring 2 arguments, 0 found');
});
it('validates doublemap, 2 args (failing with 1 arg)', (): void => {
expect(
(): any =>
extractStorageArgs(registry, storage.staking.erasStakers, [123])
).toThrow('staking.erasStakers(EraIndex, AccountId) is a double map, requiring 2 arguments, 1 found');
});
// Linked maps have been removed
it.skip('validates linked map, no args', (): void => {
expect(
extractStorageArgs(registry, storage.staking.validators, [])
).toEqual([storage.staking.validators]);
});
it.skip('validates linked map, single arg', (): void => {
expect(
extractStorageArgs(registry, storage.staking.validators, [123])
).toEqual([storage.staking.validators, 123]);
});
it.skip('validates linked map (failing with extra args)', (): void => {
expect(
(): any[] =>
extractStorageArgs(registry, storage.staking.validators, [123, 456])
).toThrow('staking.validators(AccountId) is a linked map, requiring either 0 arguments (retrieving all) or 1 argument, 2 found');
() => extractStorageArgs(registry, storage.staking.erasStakers, [123])
).toThrow('staking.erasStakers(u32, AccountId32) is a map, requiring 2 arguments, 1 found');
});
});
packages/api/src/util/validate.ts
+15 -43
View File
@@ -1,60 +1,32 @@
// Copyright 2017-2019 @polkadot/api authors & contributors
// SPDX-License-Identifier: Apache-2.0
import type { Type } from '@polkadot/types';
import type { SiLookupTypeId } from '@polkadot/types/interfaces';
import type { StorageEntry } from '@polkadot/types/primitive/types';
import type { Registry } from '@polkadot/types/types';
import { assert, isUndefined } from '@polkadot/util';
function sig (_: Registry, { method, section }: StorageEntry, args: Type[]): string {
return `${section}.${method}(${args.join(', ')})`;
}
function doDoubleMap (registry: Registry, creator: StorageEntry, args: unknown[]): [StorageEntry, [any, any]] {
const { key1, key2 } = creator.meta.type.asDoubleMap;
assert(args.length === 2, () => `${sig(registry, creator, [key1, key2])} is a double map, requiring 2 arguments, ${args.length} found`);
// pass as tuple
return [creator, args as [any, any]];
}
function doMap (registry: Registry, creator: StorageEntry, args: unknown[]): [StorageEntry] | [StorageEntry, any] {
const { key } = creator.meta.type.asMap;
assert(args.length === 1, () => `${sig(registry, creator, [key])} is a map, requiring 1 argument, ${args.length} found`);
// expand
return args.length
? [creator, args[0]]
: [creator];
}
function doNMap (registry: Registry, creator: StorageEntry, args: unknown[]): [StorageEntry, any[]] {
const { keyVec } = creator.meta.type.asNMap;
assert(args.length === keyVec.length, () => `${sig(registry, creator, keyVec)} is a multi map, requiring ${keyVec.length} arguments, ${args.length} found`);
// pass as tuple
return [creator, args];
function sig ({ lookup }: Registry, { method, section }: StorageEntry, args: SiLookupTypeId[]): string {
return `${section}.${method}(${args.map((a) => lookup.getTypeDef(a).type).join(', ')})`;
}
// sets up the arguments in the form of [creator, args] ready to be used in a storage
// call. Additionally, it verifies that the correct number of arguments have been passed
export function extractStorageArgs (registry: Registry, creator: StorageEntry, _args: unknown[]): [StorageEntry, any[]] | [StorageEntry] | [StorageEntry, any] {
export function extractStorageArgs (registry: Registry, creator: StorageEntry, _args: unknown[]): [StorageEntry, unknown[]] {
const args = _args.filter((arg) => !isUndefined(arg));
if (creator.meta.type.isDoubleMap) {
return doDoubleMap(registry, creator, args);
} else if (creator.meta.type.isMap) {
return doMap(registry, creator, args);
} else if (creator.meta.type.isNMap) {
return doNMap(registry, creator, args);
if (creator.meta.type.isPlain) {
assert(args.length === 0, () => `${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);
assert(args.length === keys.length, () => `${sig(registry, creator, keys)} is a map, requiring ${keys.length} arguments, ${args.length} found`);
}
assert(args.length === 0, () => `${sig(registry, creator, [])} does not take any arguments, ${args.length} found`);
// no args
return [creator];
// pass as tuple
return [creator, args];
}
packages/api/test/api.spec.ts
+5 -6
View File
@@ -22,6 +22,11 @@ describe('misc online tests', (): void => {
await api.disconnect();
});
it('expose rpc and rx definition', (): void => {
console.error(api.rpc.payment.queryFeeDetails.meta);
console.error(api.rx.rpc.chain.getBlock.meta);
});
it.skip('retrieves balances correctly', async (): Promise<void> => {
console.error(JSON.stringify(
await api.query.system.account('FPzukZw2mphWsXDqdkNzLaxnanjZEWH9i2vqwobTdtde5me')
@@ -64,10 +69,4 @@ describe('misc online tests', (): void => {
await api.query.society.defenderVotes('Dab4bfYTZRUDMWjYAUQuFbDreQ9mt7nULWu3Dw7jodbzVe9')
));
});
it('expose rpc and rx definition', (): void => {
console.error(api.rpc.payment.queryFeeDetails.meta);
console.error(api.rx.rpc.chain.getBlock.meta);
});
});
packages/typegen/src/extractChain.ts
+1 -1
View File
@@ -12,7 +12,7 @@ import { ApiPromise, WsProvider } from '@polkadot/api';
/** @internal */
async function run (ws: string): Promise<void> {
const provider = new WsProvider(ws);
const api = await ApiPromise.create({ provider });
const api = await ApiPromise.create({ provider, throwOnConnect: true });
const [chain, props] = await Promise.all([
api.rpc.system.chain(),
api.rpc.system.properties()
packages/typegen/src/generate/consts.ts
+13 -6
View File
@@ -6,6 +6,7 @@ import type { ExtraTypes } from './types';
import Handlebars from 'handlebars';
import lookupDefinitions from '@polkadot/types/augment/lookup/definitions';
import * as defaultDefs from '@polkadot/types/interfaces/definitions';
import { stringCamelCase } from '@polkadot/util';
@@ -17,14 +18,19 @@ const generateForMetaTemplate = Handlebars.compile(template);
/** @internal */
function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean): void {
writeFile(dest, (): string => {
const allTypes = { '@polkadot/types/interfaces': defaultDefs, ...extraTypes };
const allTypes = {
'@polkadot/types/augment': { lookup: lookupDefinitions },
'@polkadot/types/interfaces': defaultDefs,
...extraTypes
};
const imports = createImports(allTypes);
const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
}, {});
const { lookup, pallets, registry } = meta.asLatest;
const modules = meta.asLatest.modules
.filter((mod) => mod.constants.length > 0)
const modules = pallets
.filter(({ constants }) => constants.length > 0)
.map(({ constants, name }) => {
if (!isStrict) {
setImports(allDefs, imports, ['Codec']);
@@ -32,7 +38,8 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes,
const items = constants
.map(({ docs, name, type }) => {
const returnType = formatType(meta.registry, allDefs, type.toString(), imports);
const typeDef = lookup.getTypeDef(type);
const returnType = typeDef.lookupName || formatType(registry, allDefs, typeDef, imports);
setImports(allDefs, imports, [returnType]);
@@ -57,8 +64,8 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes,
isStrict,
modules,
types: [
...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
file: packagePath,
...Object.keys(imports.localTypes).sort().map<{ file: string; types: string[] }>((packagePath) => ({
file: packagePath.replace('@polkadot/types/augment', '@polkadot/types'),
types: Object.keys(imports.localTypes[packagePath])
})),
{
packages/typegen/src/generate/errors.ts
+4 -4
View File
@@ -17,11 +17,11 @@ const generateForMetaTemplate = Handlebars.compile(template);
function generateForMeta (meta: Metadata, dest: string, isStrict: boolean): void {
writeFile(dest, (): string => {
const imports = createImports({});
const modules = meta.asLatest.modules
.filter((mod) => mod.errors.length > 0)
const { lookup, pallets } = meta.asLatest;
const modules = pallets
.filter(({ errors }) => errors.isSome)
.map(({ errors, name }) => ({
items: errors
items: lookup.getSiType(errors.unwrap().type).def.asVariant.variants
.map(({ docs, name }) => ({
docs,
name: name.toString()
packages/typegen/src/generate/events.ts
+19 -13
View File
@@ -6,6 +6,7 @@ import type { ExtraTypes } from './types';
import Handlebars from 'handlebars';
import lookupDefinitions from '@polkadot/types/augment/lookup/definitions';
import * as defaultDefs from '@polkadot/types/interfaces/definitions';
import { stringCamelCase } from '@polkadot/util';
@@ -17,29 +18,34 @@ const generateForMetaTemplate = Handlebars.compile(template);
/** @internal */
function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean): void {
writeFile(dest, (): string => {
const allTypes = { '@polkadot/types/interfaces': defaultDefs, ...extraTypes };
const allTypes = {
'@polkadot/types/augment': { lookup: lookupDefinitions },
'@polkadot/types/interfaces': defaultDefs,
...extraTypes
};
const imports = createImports(allTypes);
const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
}, {});
const modules = meta.asLatest.modules
.filter((mod) => mod.events.isSome)
const { lookup, pallets, registry } = meta.asLatest;
const modules = pallets
.filter(({ events }) => events.isSome)
.map(({ events, name }) => ({
items: events
.unwrap()
.sort(compareName)
.map(({ args, docs, name }) => {
const types = args.map((type) => formatType(meta.registry, allDefs, type.toString(), imports));
items: lookup.getSiType(events.unwrap().type).def.asVariant.variants
.map(({ docs, fields, name }) => {
const args = fields
.map(({ type }) => lookup.getTypeDef(type))
.map((typeDef) => typeDef.lookupName || formatType(registry, allDefs, typeDef, imports));
setImports(allDefs, imports, types);
setImports(allDefs, imports, args);
return {
docs,
name: name.toString(),
type: types.join(', ')
type: args.join(', ')
};
}).sort(compareName),
})
.sort(compareName),
name: stringCamelCase(name)
}))
.sort(compareName);
@@ -51,7 +57,7 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes,
modules,
types: [
...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
file: packagePath,
file: packagePath.replace('@polkadot/types/augment', '@polkadot/types'),
types: Object.keys(imports.localTypes[packagePath])
})),
{
packages/typegen/src/generate/index.ts
+1
View File
@@ -5,6 +5,7 @@ export { generateDefaultConsts } from './consts';
export { generateDefaultErrors } from './errors';
export { generateDefaultEvents } from './events';
export { generateDefaultInterface } from './interfaceRegistry';
export { generateDefaultLookup } from './lookup';
export { generateDefaultQuery } from './query';
export { generateDefaultRpc } from './rpc';
export { generateDefaultTsDef } from './tsDef';
packages/typegen/src/generate/lookup.ts
+269
View File
@@ -0,0 +1,269 @@
// Copyright 2017-2021 @polkadot/typegen authors & contributors
// SPDX-License-Identifier: Apache-2.0
import type { PortableRegistry, PortableType, SiLookupTypeId, SiPath, SiTypeParameter } from '@polkadot/types/interfaces';
import type { TypeDef } from '@polkadot/types/types';
import Handlebars from 'handlebars';
import path from 'path';
import * as defaultDefinitions from '@polkadot/types/interfaces/definitions';
import { Registry } from '@polkadot/types/types';
import staticKusama from '@polkadot/types-support/metadata/static-kusama';
import staticPolkadot from '@polkadot/types-support/metadata/static-polkadot';
import staticSubstrate from '@polkadot/types-support/metadata/static-substrate';
import { isString, stringify } from '@polkadot/util';
import { createImports, exportType, initMeta, readTemplate, writeFile } from '../util';
import { typeEncoders } from './tsDef';
const MAP_ENUMS = ['Call', 'Event', 'Error', 'RawEvent'];
const WITH_TYPEDEF = false;
const generateLookupDefsTmpl = Handlebars.compile(readTemplate('lookup/defs'));
const generateLookupDefsNamedTmpl = Handlebars.compile(readTemplate('lookup/defs-named'));
const generateLookupIndexTmpl = Handlebars.compile(readTemplate('lookup/index'));
const generateLookupTypesTmpl = Handlebars.compile(readTemplate('lookup/types'));
function generateParamType (registry: Registry, { name, type }: SiTypeParameter): string {
if (type.isSome) {
const link = registry.lookup.types[type.unwrap().toNumber()];
if (link.type.path.length) {
return generateTypeDocs(registry, null, link.type.path, link.type.params);
}
}
return name.toString();
}
function generateTypeDocs (registry: Registry, id: SiLookupTypeId | null, path: SiPath, params: SiTypeParameter[]): string {
return `${id ? `${registry.createLookupType(id)}${path.length ? ': ' : ''}` : ''}${path.map((p) => p.toString()).join('::')}${params.length ? `<${params.map((p) => generateParamType(registry, p)).join(', ')}>` : ''}`;
}
function formatObject (lines: string[]): string[] {
const max = lines.length - 1;
return [
'{',
...lines.map((l, index) =>
(l.endsWith(',') || l.endsWith('{') || index === max || lines[index + 1].endsWith('}') || lines[index + 1].endsWith('}'))
? l
: `${l},`
),
'}'
];
}
function expandSet (parsed: Record<string, number>): string[] {
return formatObject(
Object.entries(parsed).reduce<string[]>((all, [k, v]) => {
all.push(`${k}: ${v}`);
return all;
}, [])
);
}
function expandObject (parsed: Record<string, string | Record<string, string>>): string[] {
if (parsed._set) {
return expandSet(parsed._set as unknown as Record<string, number>);
}
return formatObject(
Object.entries(parsed).reduce<string[]>((all, [k, v]) => {
const inner = isString(v)
? expandType(v)
: Array.isArray(v)
? [`[${(v as string[]).map((e) => `'${e}'`).join(', ')}]`]
: expandObject(v);
inner.forEach((l, index): void => {
all.push(`${
index === 0
? `${k}: ${l}`
: `${l}`
}`);
});
return all;
}, [])
);
}
function expandType (encoded: string): string[] {
if (!encoded.startsWith('{')) {
return [`'${encoded}'`];
}
return expandObject(JSON.parse(encoded) as Record<string, string | Record<string, string>>);
}
function expandDefToString ({ lookupNameRoot, type }: TypeDef, indent: number): string {
if (lookupNameRoot) {
return `'${lookupNameRoot}'`;
}
const lines = expandType(type);
let inc = 0;
return lines.map((l, index) => {
let r: string;
if (l.endsWith('{')) {
r = index === 0
? l
: `${' '.padStart(indent + inc)}${l}`;
inc += 2;
} else {
if (l.endsWith('},') || l.endsWith('}')) {
inc -= 2;
}
r = index === 0
? l
: `${' '.padStart(indent + inc)}${l}`;
}
return r;
}).join('\n');
}
function getFilteredTypes (lookup: PortableRegistry, exclude: string[] = []): [PortableType, TypeDef][] {
const named = lookup.types.filter(({ id, type: { path } }) => {
const typeDef = lookup.getTypeDef(id);
return (
// We actually only want those with lookupName set
!!typeDef.lookupName &&
!(
path.length === 2 &&
(
(
// Ensure that we match {node, kusama, *}_runtime
path[0].toString().split('_')[1] === 'runtime' &&
!['Call', 'Event'].includes(path[1].toString())
) ||
path[0].toString().startsWith('pallet_')
) &&
// Ensure we strip generics, e.g. Event<T>
MAP_ENUMS.includes(path[1].toString().split('<')[0])
) &&
!(
path.length >= 3 &&
path[path.length - 2].toString() === 'pallet' &&
// As above, cater for generics
MAP_ENUMS.includes(path[path.length - 1].toString().split('<')[0])
)
);
});
const names = named.map(({ id }) => lookup.getName(id));
return named
.filter((_, index) =>
!names.some((n, iindex) =>
index > iindex &&
n === names[index]
)
)
.map((p): [PortableType, TypeDef] => [p, lookup.getTypeDef(p.id)])
.filter(([, typeDef]) => !exclude.includes(typeDef.lookupName || '<invalid>'));
}
function generateLookupDefs (registry: Registry, filtered: [PortableType, TypeDef][], destDir: string, subPath?: string): void {
writeFile(path.join(destDir, `${subPath || 'definitions'}.ts`), (): string => {
const all = filtered.map(([{ id, type: { params, path } }, typeDef]) => {
const typeLookup = registry.createLookupType(id);
const def = expandDefToString(typeDef, subPath ? 2 : 4);
return {
docs: [
generateTypeDocs(registry, id, path, params),
WITH_TYPEDEF
? `@typeDef ${stringify(typeDef)}`
: null
].filter((d): d is string => !!d),
type: { def, typeLookup, typeName: typeDef.lookupName }
};
});
const max = all.length - 1;
return (subPath ? generateLookupDefsNamedTmpl : generateLookupDefsTmpl)({
defs: all.map(({ docs, type }, i) => {
const { def, typeLookup, typeName } = type;
return {
defs: [
[typeName || typeLookup, `${def}${i !== max ? ',' : ''}`]
].map(([n, t]) => `${n}: ${t}`),
docs
};
})
});
});
}
function generateLookupTypes (registry: Registry, filtered: [PortableType, TypeDef][], destDir: string, subPath?: string): void {
const imports = {
...createImports(
{ '@polkadot/types/interfaces': defaultDefinitions },
{ types: {} }
),
interfaces: []
};
const items = filtered.map(([, typeDef]) => {
typeDef.name = typeDef.lookupName;
return typeDef.lookupNameRoot && typeDef.lookupName
? exportType(typeDef.lookupIndex, typeDef.lookupName, typeDef.lookupNameRoot)
: typeEncoders[typeDef.info](registry, imports.definitions, typeDef, imports);
}).filter((t): t is string => !!t);
writeFile(path.join(destDir, `types${subPath ? `-${subPath}` : ''}.ts`), () => generateLookupTypesTmpl({
headerType: 'defs',
imports,
items: items.map((l) =>
l
.split('\n')
.map((l) => l.length ? ` ${l}` : '')
.join('\n')
),
types: [
...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
file: packagePath,
types: Object.keys(imports.localTypes[packagePath])
}))
]
}), true);
writeFile(path.join(destDir, 'index.ts'), () => generateLookupIndexTmpl({ headerType: 'defs' }), true);
}
function generateLookup (destDir: string, entries: [string | undefined, string][]): void {
entries.reduce<string[]>((exclude, [subPath, staticMeta]): string[] => {
const { lookup, registry } = initMeta(staticMeta).metadata.asLatest;
const filtered = getFilteredTypes(lookup, exclude);
generateLookupDefs(registry, filtered, destDir, subPath);
generateLookupTypes(registry, filtered, destDir, subPath);
return exclude.concat(
...filtered
.map(([, typeDef]) => typeDef.lookupName)
.filter((n): n is string => !!n)
);
}, []);
}
// Generate `packages/types/src/lookup/*s`, the registry of all lookup types
export function generateDefaultLookup (destDir = 'packages/types/src/augment/lookup', staticData?: string): void {
generateLookup(
destDir,
staticData
? [[undefined, staticData]]
: [
['substrate', staticSubstrate],
['polkadot', staticPolkadot],
['kusama', staticKusama]
]
);
}
packages/typegen/src/generate/query.ts
+56 -62
View File
@@ -1,15 +1,16 @@
// Copyright 2017-2021 @polkadot/typegen authors & contributors
// SPDX-License-Identifier: Apache-2.0
import type { StorageEntryMetadataLatest } from '@polkadot/types/interfaces/metadata';
import type { PortableRegistry, StorageEntryMetadataLatest } from '@polkadot/types/interfaces/metadata';
import type { Metadata } from '@polkadot/types/metadata/Metadata';
import type { Registry } from '@polkadot/types/types';
import type { ExtraTypes } from './types';
import Handlebars from 'handlebars';
import lookupDefinitions from '@polkadot/types/augment/lookup/definitions';
import * as defaultDefs from '@polkadot/types/interfaces/definitions';
import { unwrapStorageType } from '@polkadot/types/primitive/StorageKey';
import { unwrapStorageSi } from '@polkadot/types/primitive/StorageKey';
import { stringCamelCase } from '@polkadot/util';
import { compareName, createImports, formatType, getSimilarTypes, initMeta, readTemplate, setImports, TypeImports, writeFile } from '../util';
@@ -17,69 +18,56 @@ import { ModuleTypes } from '../util/imports';
// From a storage entry metadata, we return [args, returnType]
/** @internal */
function entrySignature (allDefs: Record<string, ModuleTypes>, registry: Registry, storageEntry: StorageEntryMetadataLatest, imports: TypeImports): [string, string, string] {
const outputType = unwrapStorageType(registry, storageEntry.type, storageEntry.modifier.isOptional);
function entrySignature (lookup: PortableRegistry, allDefs: Record<string, ModuleTypes>, registry: Registry, storageEntry: StorageEntryMetadataLatest, imports: TypeImports): [boolean, string, string, string] {
const outputType = lookup.getTypeDef(unwrapStorageSi(storageEntry.type));
// else if (storageEntry.type.isMap) {
// const map = storageEntry.type.asMap;
// const keyDef = lookup.getTypeDef(map.key);
// const valDef = lookup.getTypeDef(map.value);
// // Find similar types of the `key` type
// const similarTypes = getSimilarTypes(registry, allDefs, keyDef.lookupName || keyDef.type, imports);
// setImports(allDefs, imports, [
// ...similarTypes,
// valDef.lookupName || valDef.type
// ]);
// return [
// storageEntry.modifier.isOptional,
// formatType(registry, allDefs, keyDef.lookupName || keyDef.type, imports),
// `arg: ${similarTypes.join(' | ')}`,
// formatType(registry, allDefs, outputType, imports)
// ];
// }
if (storageEntry.type.isPlain) {
setImports(allDefs, imports, [storageEntry.type.asPlain.toString()]);
const typeDef = lookup.getTypeDef(storageEntry.type.asPlain);
return ['', '', formatType(registry, allDefs, outputType, imports)];
setImports(allDefs, imports, [typeDef.lookupName || typeDef.type]);
return [storageEntry.modifier.isOptional, '', '', formatType(registry, allDefs, outputType, imports)];
} else if (storageEntry.type.isMap) {
const map = storageEntry.type.asMap;
// Find similar types of the `key` type
const similarTypes = getSimilarTypes(registry, allDefs, map.key.toString(), imports);
setImports(allDefs, imports, [
...similarTypes,
map.value.toString()
]);
return [
formatType(registry, allDefs, map.key.toString(), imports),
`arg: ${similarTypes.join(' | ')}`,
formatType(registry, allDefs, outputType, imports)
];
} else if (storageEntry.type.isDoubleMap) {
const dm = storageEntry.type.asDoubleMap;
// Find similar types of `key1` and `key2` types
const similarTypes1 = getSimilarTypes(registry, allDefs, dm.key1.toString(), imports);
const similarTypes2 = getSimilarTypes(registry, allDefs, dm.key2.toString(), imports);
setImports(allDefs, imports, [
...similarTypes1,
...similarTypes2,
dm.value.toString()
]);
const key1Types = similarTypes1.join(' | ');
const key2Types = similarTypes2.join(' | ');
return [
[
formatType(registry, allDefs, dm.key1.toString(), imports),
formatType(registry, allDefs, dm.key2.toString(), imports)
].join(', '),
`arg1: ${key1Types}, arg2: ${key2Types}`,
formatType(registry, allDefs, outputType, imports)
];
} else if (storageEntry.type.isNMap) {
const nmap = storageEntry.type.asNMap;
// Find similar types for all keys
const similarTypes = nmap.keyVec.map((k) => getSimilarTypes(registry, allDefs, k.toString(), imports));
const { hashers, key, value } = storageEntry.type.asMap;
const keyDefs = hashers.length === 1
? [lookup.getTypeDef(key)]
: lookup.getSiType(key).def.asTuple.map((k) => lookup.getTypeDef(k));
const similarTypes = keyDefs.map((k) => getSimilarTypes(registry, allDefs, k.lookupName || k.type, imports));
const keyTypes = similarTypes.map((t) => t.join(' | '));
const defValue = lookup.getTypeDef(value);
setImports(allDefs, imports, [
...similarTypes.reduce<string[]>((all, t) => all.concat(t), []),
nmap.value.toString()
defValue.lookupName
? undefined
: defValue.type
]);
const keyTypes = similarTypes.map((t) => t.join(' | '));
return [
nmap.keyVec.map((k) => formatType(registry, allDefs, k.toString(), imports)).join(', '),
keyTypes.map((t, i) => `arg${i + 1}: ${t}`).join(', '),
storageEntry.modifier.isOptional,
keyDefs.map((k) => formatType(registry, allDefs, k.lookupName || k.type, imports)).join(', '),
keyTypes.map((t, i) => `arg${keyTypes.length === 1 ? '' : (i + 1)}: ${t}`).join(', '),
formatType(registry, allDefs, outputType, imports)
];
}
@@ -93,19 +81,25 @@ const generateForMetaTemplate = Handlebars.compile(template);
/** @internal */
function generateForMeta (registry: Registry, meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean): void {
writeFile(dest, (): string => {
const allTypes: ExtraTypes = { '@polkadot/types/interfaces': defaultDefs, ...extraTypes };
const allTypes: ExtraTypes = {
'@polkadot/types/augment': { lookup: lookupDefinitions },
'@polkadot/types/interfaces': defaultDefs,
...extraTypes
};
const imports = createImports(allTypes);
const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
}, {});
const modules = meta.asLatest.modules
.sort(compareName)
.filter((mod) => !mod.storage.isNone)
const { lookup, pallets } = meta.asLatest;
const modules = pallets
.filter(({ storage }) => storage.isSome)
.map(({ name, storage }) => {
const items = storage.unwrap().items
.map((storageEntry) => {
const [args, params, returnType] = entrySignature(allDefs, registry, storageEntry, imports);
const [isOptional, args, params, _returnType] = entrySignature(lookup, allDefs, registry, storageEntry, imports);
const returnType = isOptional
? `Option<${_returnType}>`
: _returnType;
return {
args,
@@ -134,7 +128,7 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr
modules,
types: [
...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
file: packagePath,
file: packagePath.replace('@polkadot/types/augment', '@polkadot/types'),
types: Object.keys(imports.localTypes[packagePath])
})),
{
packages/typegen/src/generate/rpc.ts
+1 -1
View File
@@ -132,7 +132,7 @@ export function generateRpcTypes (registry: TypeRegistry, importDefinitions: Rec
modules,
types: [
...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
file: packagePath,
file: packagePath.replace('@polkadot/types/augment', '@polkadot/types'),
types: Object.keys(imports.localTypes[packagePath])
}))
]
packages/typegen/src/generate/tsDef.ts
+69 -38
View File
@@ -35,7 +35,7 @@ function errorUnhandled (_: Registry, definitions: Record<string, ModuleTypes>,
/** @internal */
function tsExport (registry: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports): string {
return exportInterface(def.name, formatType(registry, definitions, def, imports));
return exportInterface(def.lookupIndex, def.name, formatType(registry, definitions, def, imports, false));
}
const tsBTreeMap = tsExport;
@@ -48,16 +48,16 @@ const tsPlain = tsExport;
const tsTuple = tsExport;
/** @internal */
function tsEnum (registry: Registry, definitions: Record<string, ModuleTypes>, { name: enumName, sub }: TypeDef, imports: TypeImports): string {
function tsEnum (registry: Registry, definitions: Record<string, ModuleTypes>, { lookupIndex, name: enumName, sub }: TypeDef, imports: TypeImports): string {
setImports(definitions, imports, ['Enum']);
const keys = (sub as TypeDef[]).map((def, index): string => {
const { info, name = `unknown${index}`, type } = def;
const { info, lookupName, name = `unknown${index}`, type } = def;
const getter = stringUpperFirst(stringCamelCase(name.replace(' ', '_')));
const isComplex = [TypeDefInfo.Result, TypeDefInfo.Struct, TypeDefInfo.Tuple, TypeDefInfo.Vec, TypeDefInfo.VecFixed].includes(info);
const asGetter = type === 'Null' || info === TypeDefInfo.DoNotConstruct
? ''
: createGetter(definitions, `as${getter}`, isComplex ? formatType(registry, definitions, info === TypeDefInfo.Struct ? def : type, imports) : type, imports);
: createGetter(definitions, `as${getter}`, lookupName || (isComplex ? formatType(registry, definitions, info === TypeDefInfo.Struct ? def : type, imports, false) : type), imports);
const isGetter = info === TypeDefInfo.DoNotConstruct
? ''
: createGetter(definitions, `is${getter}`, 'boolean', imports);
@@ -66,6 +66,7 @@ function tsEnum (registry: Registry, definitions: Record<string, ModuleTypes>, {
case TypeDefInfo.Compact:
case TypeDefInfo.Plain:
case TypeDefInfo.Result:
case TypeDefInfo.Si:
case TypeDefInfo.Struct:
case TypeDefInfo.Tuple:
case TypeDefInfo.Vec:
@@ -74,39 +75,54 @@ function tsEnum (registry: Registry, definitions: Record<string, ModuleTypes>, {
return `${isGetter}${asGetter}`;
case TypeDefInfo.DoNotConstruct:
return '';
case TypeDefInfo.Null:
return `${isGetter}`;
default:
throw new Error(`Enum: ${enumName || 'undefined'}: Unhandled nested "${TypeDefInfo[info]}" type`);
throw new Error(`Enum: ${enumName || 'undefined'}: Unhandled type ${TypeDefInfo[info]}, ${stringify(def)}`);
}
});
return exportInterface(enumName, 'Enum', keys.join(''));
return exportInterface(lookupIndex, enumName, 'Enum', keys.join(''));
}
function tsInt (_: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports, type: 'Int' | 'UInt' = 'Int'): string {
setImports(definitions, imports, [type]);
return exportInterface(def.name, type);
return exportInterface(def.lookupIndex, def.name, type);
}
/** @internal */
function tsNull (registry: Registry, definitions: Record<string, ModuleTypes>, { lookupIndex = -1, name }: TypeDef, imports: TypeImports): string {
setImports(definitions, imports, ['Null']);
// * @description extends [[${base}]]
const doc = `/** @name ${name || ''}${lookupIndex !== -1 ? ` (${lookupIndex})` : ''} */\n`;
return `${doc}export type ${name || ''} = Null;`;
}
/** @internal */
function tsResultGetter (registry: Registry, definitions: Record<string, ModuleTypes>, resultName = '', getter: 'Ok' | 'Err' | 'Error', def: TypeDef, imports: TypeImports): string {
const { info, type } = def;
const { info, lookupName, type } = def;
const asGetter = type === 'Null'
? ''
: (getter === 'Error' ? ' /** @deprecated Use asErr */\n' : '') + createGetter(definitions, `as${getter}`, info === TypeDefInfo.Tuple ? formatType(registry, definitions, def, imports) : type, imports);
: (getter === 'Error' ? ' /** @deprecated Use asErr */\n' : '') + createGetter(definitions, `as${getter}`, lookupName || (info === TypeDefInfo.Tuple ? formatType(registry, definitions, def, imports, false) : type), imports);
const isGetter = (getter === 'Error' ? ' /** @deprecated Use isErr */\n' : '') + createGetter(definitions, `is${getter}`, 'boolean', imports);
switch (info) {
case TypeDefInfo.Plain:
case TypeDefInfo.Si:
case TypeDefInfo.Tuple:
case TypeDefInfo.Vec:
case TypeDefInfo.Option:
return `${isGetter}${asGetter}`;
case TypeDefInfo.Null:
return `${isGetter}`;
default:
throw new Error(`Result: ${resultName}: Unhandled type ${TypeDefInfo[info]}`);
throw new Error(`Result: ${resultName}: Unhandled type ${TypeDefInfo[info]}, ${stringify(def)}`);
}
}
@@ -122,17 +138,22 @@ function tsResult (registry: Registry, definitions: Record<string, ModuleTypes>,
setImports(definitions, imports, [def.type]);
return exportInterface(def.name, formatType(registry, definitions, def, imports), inner);
const fmtType = def.lookupName && def.name !== def.lookupName
? def.lookupName
: formatType(registry, definitions, def, imports, false);
return exportInterface(def.lookupIndex, def.name, fmtType, inner);
}
/** @internal */
// eslint-disable-next-line @typescript-eslint/no-unused-vars
function tsSi (registry: Registry, definitions: Record<string, ModuleTypes>, { type }: TypeDef, imports: TypeImports): string {
throw new Error('Unable to generate string definition from TypeDefInfo.Si');
function tsSi (registry: Registry, definitions: Record<string, ModuleTypes>, typeDef: TypeDef, imports: TypeImports): string {
// FIXME
return `// SI: ${JSON.stringify(typeDef)}`;
}
/** @internal */
function tsSet (_: Registry, definitions: Record<string, ModuleTypes>, { name: setName, sub }: TypeDef, imports: TypeImports): string {
function tsSet (_: Registry, definitions: Record<string, ModuleTypes>, { lookupIndex, name: setName, sub }: TypeDef, imports: TypeImports): string {
setImports(definitions, imports, ['Set']);
const types = (sub as TypeDef[]).map(({ name }): string => {
@@ -141,20 +162,22 @@ function tsSet (_: Registry, definitions: Record<string, ModuleTypes>, { name: s
return createGetter(definitions, `is${name}`, 'boolean', imports);
});
return exportInterface(setName, 'Set', types.join(''));
return exportInterface(lookupIndex, setName, 'Set', types.join(''));
}
/** @internal */
function tsStruct (registry: Registry, definitions: Record<string, ModuleTypes>, { name: structName, sub }: TypeDef, imports: TypeImports): string {
function tsStruct (registry: Registry, definitions: Record<string, ModuleTypes>, { lookupIndex, name: structName, sub }: TypeDef, imports: TypeImports): string {
setImports(definitions, imports, ['Struct']);
const keys = (sub as TypeDef[]).map((typedef): string => {
const returnType = formatType(registry, definitions, typedef, imports);
const keys = (sub as TypeDef[]).map((def): string => {
const fmtType = def.lookupName && def.name !== def.lookupName
? def.lookupName
: formatType(registry, definitions, def, imports, false);
return createGetter(definitions, typedef.name, returnType, imports);
return createGetter(definitions, def.name, fmtType, imports);
});
return exportInterface(structName, 'Struct', keys.join(''));
return exportInterface(lookupIndex, structName, 'Struct', keys.join(''));
}
/** @internal */
@@ -166,19 +189,29 @@ function tsUInt (registry: Registry, definitions: Record<string, ModuleTypes>, d
function tsVec (registry: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports): string {
const type = (def.sub as TypeDef).type;
if (def.info === TypeDefInfo.VecFixed && type === 'u8') {
setImports(definitions, imports, ['U8aFixed']);
if (type === 'u8') {
if (def.info === TypeDefInfo.VecFixed) {
setImports(definitions, imports, ['U8aFixed']);
return exportType(def.name, 'U8aFixed');
return exportType(def.lookupIndex, def.name, 'U8aFixed');
} else {
setImports(definitions, imports, ['Bytes']);
return exportType(def.lookupIndex, def.name, 'Bytes');
}
}
return exportInterface(def.name, formatType(registry, definitions, def, imports));
const fmtType = def.lookupName && def.name !== def.lookupName
? def.lookupName
: formatType(registry, definitions, def, imports, false);
return exportInterface(def.lookupIndex, def.name, fmtType);
}
// handlers are defined externally to use - this means that when we do a
// `generators[typedef.info](...)` TS will show any unhandled types. Rather
// we are being explicit in having no handlers where we do not support (yet)
const encoders: Record<TypeDefInfo, (registry: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports) => string> = {
export const typeEncoders: Record<TypeDefInfo, (registry: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports) => string> = {
[TypeDefInfo.BTreeMap]: tsBTreeMap,
[TypeDefInfo.BTreeSet]: tsBTreeSet,
[TypeDefInfo.Compact]: tsCompact,
@@ -187,7 +220,7 @@ const encoders: Record<TypeDefInfo, (registry: Registry, definitions: Record<str
[TypeDefInfo.HashMap]: tsHashMap,
[TypeDefInfo.Int]: tsInt,
[TypeDefInfo.Linkage]: errorUnhandled,
[TypeDefInfo.Null]: errorUnhandled,
[TypeDefInfo.Null]: tsNull,
[TypeDefInfo.Option]: tsOption,
[TypeDefInfo.Plain]: tsPlain,
[TypeDefInfo.Range]: errorUnhandled,
@@ -206,7 +239,7 @@ function generateInterfaces (registry: Registry, definitions: Record<string, Mod
return Object.entries(types).map(([name, type]): [string, string] => {
const def = getTypeDef(isString(type) ? type : stringify(type), { name });
return [name, encoders[def.info](registry, definitions, def, imports)];
return [name, typeEncoders[def.info](registry, definitions, def, imports)];
});
}
@@ -220,25 +253,23 @@ const templateTypes = readTemplate('tsDef/types');
const generateTsDefTypesTemplate = Handlebars.compile(templateTypes);
/** @internal */
function generateTsDefFor (registry: Registry, importDefinitions: { [importPath: string]: Record<string, ModuleTypes> }, defName: string, { types }: { types: Record<string, any> }, outputDir: string): void {
export function generateTsDefFor (registry: Registry, importDefinitions: { [importPath: string]: Record<string, ModuleTypes> }, defName: string, { types }: { types: Record<string, any> }, outputDir: string): void {
const imports = { ...createImports(importDefinitions, { types }), interfaces: [] } as Imports;
const definitions = imports.definitions;
const interfaces = generateInterfaces(registry, definitions, { types }, imports);
const items = interfaces.sort((a, b): number => a[0].localeCompare(b[0])).map(([, definition]): string => definition);
const importTypes = [
...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
file: packagePath,
types: Object.keys(imports.localTypes[packagePath])
}))
];
const items = interfaces.sort((a, b) => a[0].localeCompare(b[0])).map(([, definition]) => definition);
writeFile(path.join(outputDir, defName, 'types.ts'), () => generateTsDefModuleTypesTemplate({
headerType: 'defs',
imports,
items,
name: defName,
types: importTypes
types: [
...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
file: packagePath.replace('@polkadot/types/augment', '@polkadot/types'),
types: Object.keys(imports.localTypes[packagePath])
}))
]
}), true);
writeFile(path.join(outputDir, defName, 'index.ts'), () => generateTsDefIndexTemplate({ headerType: 'defs' }), true);
}
packages/typegen/src/generate/tx.ts
+36 -13
View File
@@ -7,6 +7,7 @@ import type { ExtraTypes } from './types';
import Handlebars from 'handlebars';
import lookupDefinitions from '@polkadot/types/augment/lookup/definitions';
import * as defaultDefs from '@polkadot/types/interfaces/definitions';
import { Text } from '@polkadot/types/primitive';
import { stringCamelCase } from '@polkadot/util';
@@ -30,32 +31,54 @@ const generateForMetaTemplate = Handlebars.compile(template);
/** @internal */
function generateForMeta (registry: Registry, meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean): void {
writeFile(dest, (): string => {
const allTypes: ExtraTypes = { '@polkadot/types/interfaces': defaultDefs, ...extraTypes };
const allTypes: ExtraTypes = {
'@polkadot/types/augment': { lookup: lookupDefinitions },
'@polkadot/types/interfaces': defaultDefs,
...extraTypes
};
const imports = createImports(allTypes);
const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
}, {});
const modules = meta.asLatest.modules
.filter(({ calls }) => calls.unwrapOr([]).length !== 0)
const { lookup, pallets } = meta.asLatest;
const modules = pallets
.sort(compareName)
.filter(({ calls }) => calls.isSome)
.map(({ calls, name }) => {
setImports(allDefs, imports, ['Call', 'Extrinsic', 'SubmittableExtrinsic']);
const items = calls.unwrap()
.map(({ args, docs, name }) => {
const params = args
.map(({ name, type }) => {
const typeStr = type.toString();
const sectionName = stringCamelCase(name);
const items = lookup.getSiType(calls.unwrap().type).def.asVariant.variants
.map(({ docs, fields, name }) => {
const typesInfo = fields.map(({ name, type, typeName }, index): [string, string, string] => {
const typeDef = registry.lookup.getTypeDef(type);
return [
name.isSome
? mapName(name.unwrap())
: `param${index}`,
typeName.isSome
? typeName.toString()
: typeDef.type,
typeDef.isFromSi
? typeDef.type
: typeDef.lookupName || typeDef.type
];
});
const params = typesInfo
.map(([name,, typeStr]) => {
const similarTypes = getSimilarTypes(registry, allDefs, typeStr, imports);
setImports(allDefs, imports, [typeStr, ...similarTypes]);
return `${mapName(name)}: ${similarTypes.join(' | ')}`;
return `${name}: ${similarTypes.join(' | ')}`;
})
.join(', ');
return {
args: args.map(({ type }) => formatType(registry, allDefs, type.toString(), imports)).join(', '),
args: typesInfo.map(([,, typeStr]) =>
formatType(registry, allDefs, typeStr, imports)
).join(', '),
docs,
name: stringCamelCase(name),
params
@@ -65,7 +88,7 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr
return {
items,
name: stringCamelCase(name)
name: sectionName
};
})
.sort(compareName);
@@ -77,7 +100,7 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr
modules,
types: [
...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
file: packagePath,
file: packagePath.replace('@polkadot/types/augment', '@polkadot/types'),
types: Object.keys(imports.localTypes[packagePath])
})),
{
packages/typegen/src/interfacesTs.ts
+2 -1
View File
@@ -1,9 +1,10 @@
// Copyright 2017-2021 @polkadot/typegen authors & contributors
// SPDX-License-Identifier: Apache-2.0
import { generateDefaultConsts, generateDefaultErrors, generateDefaultEvents, generateDefaultInterface, generateDefaultQuery, generateDefaultRpc, generateDefaultTsDef, generateDefaultTx } from './generate';
import { generateDefaultConsts, generateDefaultErrors, generateDefaultEvents, generateDefaultInterface, generateDefaultLookup, generateDefaultQuery, generateDefaultRpc, generateDefaultTsDef, generateDefaultTx } from './generate';
export function main (): void {
generateDefaultLookup();
generateDefaultInterface();
generateDefaultConsts();
packages/typegen/src/metadataMd.ts
+59 -52
View File
@@ -6,7 +6,7 @@ import type { Codec, DefinitionRpcParam } from '@polkadot/types/types';
import fs from 'fs';
import { GenericCall as Call, Metadata, TypeRegistry, Vec } from '@polkadot/types';
import { Metadata, TypeRegistry, Vec } from '@polkadot/types';
import * as definitions from '@polkadot/types/interfaces/definitions';
import { getStorage as getSubstrateStorage } from '@polkadot/types/metadata/decorate/storage/getStorage';
import { Text } from '@polkadot/types/primitive';
@@ -45,9 +45,15 @@ const DESC_STORAGE = `The following sections contain Storage methods are part of
/** @internal */
function docsVecToMarkdown (docLines: Vec<Text>, indent = 0): string {
const md = docLines
.map((docLine) => docLine && docLine.substring(1)) // trim the leading space
.reduce((md, docLine): string => // generate paragraphs
!docLine.trim().length
.map((docLine) =>
docLine
.toString()
.trimStart()
.replace(/^r"/g, '')
.trimStart()
)
.reduce((md, docLine) => // generate paragraphs
!docLine.length
? `${md}\n\n` // empty line
: /^[*-]/.test(docLine.trimStart()) && !md.endsWith('\n\n')
? `${md}\n\n${docLine}` // line calling for a preceding linebreak
@@ -162,25 +168,25 @@ function addRpc (): string {
}
/** @internal */
function addConstants (metadata: MetadataLatest): string {
function addConstants ({ lookup, pallets }: MetadataLatest): string {
return renderPage({
description: DESC_CONSTANTS,
sections: metadata.modules
sections: pallets
.sort(sortByName)
.filter((moduleMetadata) => !moduleMetadata.constants.isEmpty)
.map((moduleMetadata) => {
const sectionName = stringLowerFirst(moduleMetadata.name);
.filter(({ constants }) => !constants.isEmpty)
.map(({ constants, name }) => {
const sectionName = stringLowerFirst(name);
return {
items: moduleMetadata.constants
items: constants
.sort(sortByName)
.map((func) => {
const methodName = stringCamelCase(func.name);
.map(({ docs, name, type }) => {
const methodName = stringCamelCase(name);
return {
interface: '`' + `api.consts.${sectionName}.${methodName}` + '`',
name: `${methodName}: ` + '`' + func.type.toString() + '`',
...(func.docs.length && { summary: func.docs })
name: `${methodName}: ` + '`' + lookup.getTypeDef(type).type + '`',
...(docs.length && { summary: docs })
};
}),
name: sectionName
@@ -191,9 +197,9 @@ function addConstants (metadata: MetadataLatest): string {
}
/** @internal */
function addStorage (metadata: MetadataLatest): string {
const { substrate } = getSubstrateStorage(metadata.registry);
const moduleSections = metadata.modules
function addStorage ({ lookup, pallets, registry }: MetadataLatest): string {
const { substrate } = getSubstrateStorage(registry);
const moduleSections = pallets
.sort(sortByName)
.filter((moduleMetadata) => !moduleMetadata.storage.isNone)
.map((moduleMetadata): Section => {
@@ -203,15 +209,18 @@ function addStorage (metadata: MetadataLatest): string {
items: moduleMetadata.storage.unwrap().items
.sort(sortByName)
.map((func) => {
const arg = func.type.isMap
? ('`' + func.type.asMap.key.toString() + '`')
: func.type.isDoubleMap
? ('`' + func.type.asDoubleMap.key1.toString() + ', ' + func.type.asDoubleMap.key2.toString() + '`')
: func.type.isNMap
? ('`' + func.type.asNMap.keyVec.map((k) => k.toString()).join(', ') + '`')
: '';
let arg = '';
if (func.type.isMap) {
const { hashers, key } = func.type.asMap;
arg = hashers.length === 1
? ('`' + key.toString() + '`')
: ('`' + lookup.getSiType(key).def.asTuple.map((t) => t).join(', ') + '`');
}
const methodName = stringLowerFirst(func.name);
const outputType = unwrapStorageType(metadata.registry, func.type, func.modifier.isOptional);
const outputType = unwrapStorageType(registry, func.type, func.modifier.isOptional);
return {
interface: '`' + `api.query.${sectionName}.${methodName}` + '`',
@@ -229,12 +238,10 @@ function addStorage (metadata: MetadataLatest): string {
description: 'These are well-known keys that are always available to the runtime implementation of any Substrate-based network.',
items: Object.entries(substrate).map(([name, { meta }]) => {
const arg = meta.type.isMap
? ('`' + meta.type.asMap.key.toString() + '`')
: meta.type.isDoubleMap
? ('`' + meta.type.asDoubleMap.key1.toString() + ', ' + meta.type.asDoubleMap.key2.toString() + '`')
: '';
? ('`' + lookup.getTypeDef(meta.type.asMap.key).type + '`')
: '';
const methodName = stringLowerFirst(name);
const outputType = unwrapStorageType(metadata.registry, meta.type, meta.modifier.isOptional);
const outputType = unwrapStorageType(registry, meta.type, meta.modifier.isOptional);
return {
interface: '`' + `api.query.substrate.${methodName}` + '`',
@@ -249,26 +256,26 @@ function addStorage (metadata: MetadataLatest): string {
}
/** @internal */
function addExtrinsics (metadata: MetadataLatest): string {
function addExtrinsics ({ lookup, pallets }: MetadataLatest): string {
return renderPage({
description: DESC_EXTRINSICS,
sections: metadata.modules
sections: pallets
.sort(sortByName)
.filter((meta) => !meta.calls.isNone && meta.calls.unwrap().length !== 0)
.map((meta) => {
const sectionName = stringCamelCase(meta.name);
.filter(({ calls }) => calls.isSome)
.map(({ calls, name }) => {
const sectionName = stringCamelCase(name);
return {
items: meta.calls.unwrap()
items: lookup.getSiType(calls.unwrap().type).def.asVariant.variants
.sort(sortByName)
.map((func) => {
const methodName = stringCamelCase(func.name);
const args = Call.filterOrigin(func).map(({ name, type }) => `${name.toString()}: ` + '`' + type.toString() + '`').join(', ');
.map(({ docs, fields, name }, index) => {
const methodName = stringCamelCase(name);
const args = fields.map(({ name, type }) => `${name.isSome ? name.toString() : `param${index}`}: ` + '`' + lookup.getTypeDef(type).type + '`').join(', ');
return {
interface: '`' + `api.tx.${sectionName}.${methodName}` + '`',
name: `${methodName}(${args})`,
...(func.docs.length && { summary: func.docs })
...(docs.length && { summary: docs })
};
}),
name: sectionName
@@ -279,23 +286,23 @@ function addExtrinsics (metadata: MetadataLatest): string {
}
/** @internal */
function addEvents (metadata: MetadataLatest): string {
function addEvents ({ lookup, pallets }: MetadataLatest): string {
return renderPage({
description: DESC_EVENTS,
sections: metadata.modules
sections: pallets
.sort(sortByName)
.filter((meta) => !meta.events.isNone && meta.events.unwrap().length !== 0)
.filter(({ events }) => events.isSome)
.map((meta) => ({
items: meta.events.unwrap()
items: lookup.getSiType(meta.events.unwrap().type).def.asVariant.variants
.sort(sortByName)
.map((func) => {
const methodName = func.name.toString();
const args = func.args.map((type): string => '`' + type.toString() + '`').join(', ');
.map(({ docs, fields, name }) => {
const methodName = name.toString();
const args = fields.map(({ type }) => '`' + lookup.getTypeDef(type).type + '`').join(', ');
return {
interface: '`' + `api.events.${stringCamelCase(meta.name)}.${methodName}.is` + '`',
name: `${methodName}(${args})`,
...(func.docs.length && { summary: func.docs })
...(docs.length && { summary: docs })
};
}),
name: stringCamelCase(meta.name)
@@ -305,14 +312,14 @@ function addEvents (metadata: MetadataLatest): string {
}
/** @internal */
function addErrors (metadata: MetadataLatest): string {
function addErrors ({ lookup, pallets }: MetadataLatest): string {
return renderPage({
description: DESC_ERRORS,
sections: metadata.modules
sections: pallets
.sort(sortByName)
.filter((moduleMetadata) => !moduleMetadata.errors.isEmpty)
.filter(({ errors }) => errors.isSome)
.map((moduleMetadata) => ({
items: moduleMetadata.errors
items: lookup.getSiType(moduleMetadata.errors.unwrap().type).def.asVariant.variants
.sort(sortByName)
.map((error) => ({
interface: '`' + `api.errors.${stringCamelCase(moduleMetadata.name)}.${error.name.toString()}.is` + '`',
packages/typegen/src/templates/lookup/defs-named.hbs
+15
View File
@@ -0,0 +1,15 @@
{{> header }}
/* eslint-disable sort-keys */
import type { DefinitionsTypes } from '../../types';
export default {
{{#each defs}}
{{> docs}}
{{#each defs}}
{{{this}}}
{{/each}}
{{/each}}
} as DefinitionsTypes;
{{> footer }}
packages/typegen/src/templates/lookup/defs.hbs
+18
View File
@@ -0,0 +1,18 @@
{{> header }}
/* eslint-disable sort-keys */
import type { Definitions } from '../../types';
export default {
rpc: {},
types: {
{{#each defs}}
{{> docs}}
{{#each defs}}
{{{this}}}
{{/each}}
{{/each}}
}
} as Definitions;
{{> footer }}
packages/typegen/src/templates/lookup/index.hbs
+4
View File
@@ -0,0 +1,4 @@
{{> header }}
export * from './types';
{{> footer }}
packages/typegen/src/templates/lookup/types.hbs
+12
View File
@@ -0,0 +1,12 @@
{{> header }}
{{{ imports }}}
declare module '@polkadot/types/lookup' {
{{#each items}}
{{{this}}}
{{/each}}
}
{{> footer }}
packages/typegen/src/util/formatting.ts
+49 -41
View File
@@ -55,7 +55,7 @@ Handlebars.registerHelper({
...types
];
return defs.reduce((result, { file, types }): string => {
return [...defs].sort((a, b) => a.file.localeCompare(b.file)).reduce((result, { file, types }): string => {
return types.length
? `${result}import type { ${types.sort().join(', ')} } from '${file}';\n`
: result;
@@ -71,9 +71,9 @@ Handlebars.registerHelper({
// helper to generate a `export interface <Name> extends <Base> {<Body>}
/** @internal */
export function exportInterface (name = '', base: string, body = ''): string {
export function exportInterface (lookupIndex = -1, name = '', base: string, body = ''): string {
// * @description extends [[${base}]]
const doc = `/** @name ${name} */\n`;
const doc = `/** @name ${name}${lookupIndex !== -1 ? ` (${lookupIndex})` : ''} */\n`;
return `${doc}export interface ${name} extends ${base} {${body.length ? '\n' : ''}${body}}`;
}
@@ -82,19 +82,19 @@ export function exportInterface (name = '', base: string, body = ''): string {
// but since we don't want type alias (TS doesn't preserve names) we use
// interface here.
/** @internal */
export function exportType (name = '', base: string): string {
return exportInterface(name, base);
export function exportType (lookupIndex = -1, name = '', base: string): string {
return exportInterface(lookupIndex, name, base);
}
const formatters: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => string> = {
[TypeDefInfo.Compact]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
setImports(definitions, imports, ['Compact']);
const sub = typeDef.sub as TypeDef;
return paramsNotation('Compact', formatType(registry, definitions, sub.lookupName || sub.type, imports, withShortcut));
setImports(definitions, imports, ['Compact', sub.lookupName]);
return paramsNotation('Compact', sub.lookupName || formatType(registry, definitions, sub.type, imports, withShortcut));
},
[TypeDefInfo.DoNotConstruct]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
[TypeDefInfo.DoNotConstruct]: (registry: Registry, { lookupName }: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
setImports(definitions, imports, ['DoNotConstruct']);
return 'DoNotConstruct';
@@ -118,11 +118,11 @@ const formatters: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef, def
return 'Null';
},
[TypeDefInfo.Option]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
setImports(definitions, imports, ['Option']);
const sub = (typeDef.sub as TypeDef);
return paramsNotation('Option', formatType(registry, definitions, sub.lookupName || sub.type, imports, withShortcut));
setImports(definitions, imports, ['Option', sub.lookupName]);
return paramsNotation('Option', sub.lookupName || formatType(registry, definitions, sub.type, imports, withShortcut));
},
[TypeDefInfo.Plain]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
setImports(definitions, imports, [typeDef.type]);
@@ -139,31 +139,39 @@ const formatters: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef, def
return formatType(registry, definitions, registry.lookup.getTypeDef(typeDef.type), imports, withShortcut);
},
[TypeDefInfo.Struct]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
setImports(definitions, imports, ['Struct']);
if (typeDef.lookupName) {
return typeDef.lookupName;
}
const sub = typeDef.sub as TypeDef[];
setImports(definitions, imports, ['Struct', ...sub.map(({ lookupName }) => lookupName)]);
return `{${withShortcut ? ' ' : '\n'}${
((typeDef.sub as TypeDef[]).map(({ lookupName, name, type }, index) => [
sub.map(({ lookupName, name, type }, index) => [
name || `unknown${index}`,
formatType(registry, definitions, lookupName || type, imports, withShortcut)
])).map(([k, t]) => `${withShortcut ? '' : ' readonly '}${k}: ${t};`).join(withShortcut ? ' ' : '\n')
lookupName || formatType(registry, definitions, type, imports, withShortcut)
]).map(([k, t]) => `${withShortcut ? '' : ' readonly '}${k}: ${t};`).join(withShortcut ? ' ' : '\n')
}${withShortcut ? ' ' : '\n '}} & Struct`;
},
[TypeDefInfo.Tuple]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
setImports(definitions, imports, ['ITuple']);
const sub = typeDef.sub as TypeDef[];
setImports(definitions, imports, ['ITuple', ...sub.map(({ lookupName }) => lookupName)]);
// `(a,b)` gets transformed into `ITuple<[a, b]>`
return paramsNotation('ITuple', `[${
((typeDef.sub as TypeDef[]).map(({ lookupName, type }) =>
formatType(registry, definitions, lookupName || type, imports, withShortcut)
)).join(', ')
sub.map(({ lookupName, type }) =>
lookupName || formatType(registry, definitions, type, imports, withShortcut)
).join(', ')
}]`);
},
[TypeDefInfo.Vec]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
setImports(definitions, imports, ['Vec']);
const sub = (typeDef.sub as TypeDef);
return paramsNotation('Vec', formatType(registry, definitions, sub.lookupName || sub.type, imports, withShortcut));
setImports(definitions, imports, ['Vec', sub.lookupName]);
return paramsNotation('Vec', sub.lookupName || formatType(registry, definitions, sub.type, imports, withShortcut));
},
[TypeDefInfo.VecFixed]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
const sub = (typeDef.sub as TypeDef);
@@ -174,44 +182,44 @@ const formatters: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef, def
return 'U8aFixed';
}
setImports(definitions, imports, ['Vec']);
setImports(definitions, imports, ['Vec', sub.lookupName]);
return paramsNotation('Vec', formatType(registry, definitions, sub.lookupName || sub.type, imports, withShortcut));
return paramsNotation('Vec', sub.lookupName || formatType(registry, definitions, sub.type, imports, withShortcut));
},
[TypeDefInfo.BTreeMap]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
setImports(definitions, imports, ['BTreeMap']);
const [keyDef, valDef] = (typeDef.sub as TypeDef[]);
return `BTreeMap<${formatType(registry, definitions, keyDef.lookupName || keyDef.type, imports, withShortcut)}, ${formatType(registry, definitions, valDef.lookupName || valDef.type, imports, withShortcut)}>`;
setImports(definitions, imports, ['BTreeMap', keyDef.lookupName, valDef.lookupName]);
return `BTreeMap<${keyDef.lookupName || formatType(registry, definitions, keyDef.type, imports, withShortcut)}, ${valDef.lookupName || formatType(registry, definitions, valDef.type, imports, withShortcut)}>`;
},
[TypeDefInfo.BTreeSet]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
setImports(definitions, imports, ['BTreeSet']);
const valDef = typeDef.sub as TypeDef;
return `BTreeSet<${formatType(registry, definitions, valDef.lookupName || valDef.type, imports, withShortcut)}>`;
setImports(definitions, imports, ['BTreeSet', valDef.lookupName]);
return `BTreeSet<${valDef.lookupName || formatType(registry, definitions, valDef.type, imports, withShortcut)}>`;
},
[TypeDefInfo.HashMap]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
setImports(definitions, imports, ['HashMap']);
const [keyDef, valDef] = (typeDef.sub as TypeDef[]);
return `HashMap<${formatType(registry, definitions, keyDef.lookupName || keyDef.type, imports, withShortcut)}, ${formatType(registry, definitions, valDef.lookupName || valDef.type, imports, withShortcut)}>`;
setImports(definitions, imports, ['HashMap', keyDef.lookupName, valDef.lookupName]);
return `HashMap<${keyDef.lookupName || formatType(registry, definitions, keyDef.type, imports, withShortcut)}, ${valDef.lookupName || formatType(registry, definitions, valDef.type, imports, withShortcut)}>`;
},
[TypeDefInfo.Linkage]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
setImports(definitions, imports, ['Linkage']);
const sub = (typeDef.sub as TypeDef);
return paramsNotation('Linkage', formatType(registry, definitions, sub.lookupName || sub.type, imports, withShortcut));
setImports(definitions, imports, ['Linkage', sub.lookupName]);
return paramsNotation('Linkage', sub.lookupName || formatType(registry, definitions, sub.type, imports, withShortcut));
},
[TypeDefInfo.Result]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
setImports(definitions, imports, ['Result']);
const [okDef, errDef] = (typeDef.sub as TypeDef[]);
return `Result<${formatType(registry, definitions, okDef.lookupName || okDef.type, imports, withShortcut)}, ${formatType(registry, definitions, errDef.lookupName || errDef.type, imports, withShortcut)}>`;
setImports(definitions, imports, ['Result', okDef.lookupName, errDef.lookupName]);
return `Result<${okDef.lookupName || formatType(registry, definitions, okDef.type, imports, withShortcut)}, ${errDef.lookupName || formatType(registry, definitions, errDef.type, imports, withShortcut)}>`;
}
};
@@ -237,7 +245,7 @@ export function formatType (registry: Registry, definitions: Record<string, Modu
typeDef = type;
}
setImports(definitions, imports, [typeDef.type]);
setImports(definitions, imports, [typeDef.lookupName || typeDef.type]);
return formatters[typeDef.info](registry, typeDef, definitions, imports, withShortcut);
}
packages/typegen/src/util/imports.ts
+2 -2
View File
@@ -36,10 +36,10 @@ export interface TypeImports {
// Maps the types as found to the source location. This is used to generate the
// imports in the output file, dep-duped and sorted
/** @internal */
export function setImports (allDefs: Record<string, ModuleTypes>, imports: TypeImports, types: string[]): void {
export function setImports (allDefs: Record<string, ModuleTypes>, imports: TypeImports, types: (string | null | undefined)[]): void {
const { codecTypes, extrinsicTypes, genericTypes, ignoredTypes, localTypes, metadataTypes, primitiveTypes, typesTypes } = imports;
types.forEach((type): void => {
types.filter((t): t is string => !!t).forEach((type): void => {
if (ignoredTypes.includes(type)) {
// do nothing
} else if (['AnyNumber', 'CallFunction', 'Codec', 'IExtrinsic', 'ITuple'].includes(type)) {
packages/typegen/src/util/initMeta.ts
+3 -3
View File
@@ -4,7 +4,7 @@
import type { ExtraTypes } from '../generate/types';
import { Metadata, TypeRegistry } from '@polkadot/types';
import staticData from '@polkadot/types-support/metadata/static-substrate';
import staticSubstrate from '@polkadot/types-support/metadata/static-substrate';
import { registerDefinitions } from './register';
@@ -13,12 +13,12 @@ interface Result {
registry: TypeRegistry;
}
export function initMeta (data = staticData, extraTypes: ExtraTypes = {}): Result {
export function initMeta (staticMeta = staticSubstrate, extraTypes: ExtraTypes = {}): Result {
const registry = new TypeRegistry();
registerDefinitions(registry, extraTypes);
const metadata = new Metadata(registry, data);
const metadata = new Metadata(registry, staticMeta);
registry.setMetadata(metadata);
packages/types-support/src/metadata/static-kusama.ts
+1 -1
View File
@@ -1,6 +1,6 @@
// Copyright 2017-2021 @polkadot/types-support authors & contributors
// SPDX-License-Identifier: Apache-2.0
import metadata from './v13/kusama-hex';
import metadata from './v14/kusama-hex';
export default metadata;
packages/types-support/src/metadata/static-polkadot.ts
+1 -1
View File
@@ -1,6 +1,6 @@
// Copyright 2017-2021 @polkadot/types-support authors & contributors
// SPDX-License-Identifier: Apache-2.0
import metadata from './v13/polkadot-hex';
import metadata from './v14/polkadot-hex';
export default metadata;
packages/types-support/src/metadata/static-substrate.ts
+1 -1
View File
@@ -1,6 +1,6 @@
// Copyright 2017-2021 @polkadot/types-support authors & contributors
// SPDX-License-Identifier: Apache-2.0
import metadata from './v13/substrate-hex';
import metadata from './v14/substrate-hex';
export default metadata;
packages/types-support/src/metadata/v14/kusama-hex.ts
+1 -1
View File
File diff suppressed because one or more lines are too long
packages/types-support/src/metadata/v14/kusama-json.json
+624 -412
View File
File diff suppressed because it is too large Load Diff
packages/types-support/src/metadata/v14/kusama-types.json
+8780 -4052
View File
File diff suppressed because it is too large Load Diff
packages/types-support/src/metadata/v14/polkadot-hex.ts
+1 -1
View File
File diff suppressed because one or more lines are too long
packages/types-support/src/metadata/v14/polkadot-json.json
+389 -352
View File
File diff suppressed because it is too large Load Diff
packages/types-support/src/metadata/v14/polkadot-types.json
+1483 -1351
View File
File diff suppressed because it is too large Load Diff
packages/types-support/src/metadata/v14/substrate-hex.ts
+1 -1
View File
File diff suppressed because one or more lines are too long
packages/types-support/src/metadata/v14/substrate-json.json
+394 -458
View File
File diff suppressed because it is too large Load Diff
packages/types-support/src/metadata/v14/substrate-types.json
+1595 -1896
View File
File diff suppressed because it is too large Load Diff
packages/types/src/augment/lookup/definitions.ts
+17
View File
@@ -0,0 +1,17 @@
// Copyright 2017-2021 @polkadot/api authors & contributors
// SPDX-License-Identifier: Apache-2.0
import type { Definitions } from '../../types';
import kusama from './kusama';
import polkadot from './polkadot';
import substrate from './substrate';
export default {
rpc: {},
types: {
...polkadot,
...kusama,
...substrate
}
} as Definitions;
packages/types/src/augment/lookup/index.ts
+4
View File
@@ -0,0 +1,4 @@
// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
/* eslint-disable */
export * from './types';
packages/types/src/augment/lookup/kusama.ts
+1323
View File
File diff suppressed because it is too large Load Diff
packages/types/src/augment/lookup/polkadot.ts
+101
View File
@@ -0,0 +1,101 @@
// Auto-generated via `yarn polkadot-types-from-`, do not edit
/* eslint-disable */
/* eslint-disable sort-keys */
import type { DefinitionsTypes } from '../../types';
export default {
/**
* Lookup66: polkadot_runtime_common::claims::EthereumAddress
**/
PolkadotRuntimeCommonClaimsEthereumAddress: '[u8;20]',
/**
* Lookup72: polkadot_runtime::ProxyType
**/
PolkadotRuntimeProxyType: {
_enum: ['Any', 'NonTransfer', 'Governance', 'Staking', 'Unused4', 'IdentityJudgement', 'CancelProxy']
},
/**
* Lookup139: polkadot_runtime::SessionKeys
**/
PolkadotRuntimeSessionKeys: {
grandpa: 'SpFinalityGrandpaAppPublic',
babe: 'SpConsensusBabeAppPublic',
imOnline: 'PalletImOnlineSr25519AppSr25519Public',
paraValidator: 'PolkadotPrimitivesV0ValidatorAppPublic',
paraAssignment: 'PolkadotPrimitivesV1AssignmentAppPublic',
authorityDiscovery: 'SpAuthorityDiscoveryAppPublic'
},
/**
* Lookup140: polkadot_primitives::v0::validator_app::Public
**/
PolkadotPrimitivesV0ValidatorAppPublic: 'SpCoreSr25519Public',
/**
* Lookup141: polkadot_primitives::v1::assignment_app::Public
**/
PolkadotPrimitivesV1AssignmentAppPublic: 'SpCoreSr25519Public',
/**
* Lookup175: polkadot_runtime_common::claims::EcdsaSignature
**/
PolkadotRuntimeCommonClaimsEcdsaSignature: '[u8;65]',
/**
* Lookup180: polkadot_runtime_common::claims::StatementKind
**/
PolkadotRuntimeCommonClaimsStatementKind: {
_enum: ['Regular', 'Saft']
},
/**
* Lookup233: polkadot_runtime::NposCompactSolution16
**/
PolkadotRuntimeNposCompactSolution16: {
votes1: 'Vec<(Compact<u32>,Compact<u16>)>',
votes2: 'Vec<(Compact<u32>,(Compact<u16>,Compact<PerU16>),Compact<u16>)>',
votes3: 'Vec<(Compact<u32>,[(Compact<u16>,Compact<PerU16>);2],Compact<u16>)>',
votes4: 'Vec<(Compact<u32>,[(Compact<u16>,Compact<PerU16>);3],Compact<u16>)>',
votes5: 'Vec<(Compact<u32>,[(Compact<u16>,Compact<PerU16>);4],Compact<u16>)>',
votes6: 'Vec<(Compact<u32>,[(Compact<u16>,Compact<PerU16>);5],Compact<u16>)>',
votes7: 'Vec<(Compact<u32>,[(Compact<u16>,Compact<PerU16>);6],Compact<u16>)>',
votes8: 'Vec<(Compact<u32>,[(Compact<u16>,Compact<PerU16>);7],Compact<u16>)>',
votes9: 'Vec<(Compact<u32>,[(Compact<u16>,Compact<PerU16>);8],Compact<u16>)>',
votes10: 'Vec<(Compact<u32>,[(Compact<u16>,Compact<PerU16>);9],Compact<u16>)>',
votes11: 'Vec<(Compact<u32>,[(Compact<u16>,Compact<PerU16>);10],Compact<u16>)>',
votes12: 'Vec<(Compact<u32>,[(Compact<u16>,Compact<PerU16>);11],Compact<u16>)>',
votes13: 'Vec<(Compact<u32>,[(Compact<u16>,Compact<PerU16>);12],Compact<u16>)>',
votes14: 'Vec<(Compact<u32>,[(Compact<u16>,Compact<PerU16>);13],Compact<u16>)>',
votes15: 'Vec<(Compact<u32>,[(Compact<u16>,Compact<PerU16>);14],Compact<u16>)>',
votes16: 'Vec<(Compact<u32>,[(Compact<u16>,Compact<PerU16>);15],Compact<u16>)>'
},
/**
* Lookup290: polkadot_runtime::OriginCaller
**/
PolkadotRuntimeOriginCaller: {
_enum: {
system: 'FrameSystemRawOrigin',
Unused1: 'Null',
Unused2: 'Null',
Void: 'SpCoreVoid',
Unused4: 'Null',
Unused5: 'Null',
Unused6: 'Null',
Unused7: 'Null',
Unused8: 'Null',
Unused9: 'Null',
Unused10: 'Null',
Unused11: 'Null',
Unused12: 'Null',
Unused13: 'Null',
Unused14: 'Null',
Council: 'PalletCollectiveRawOrigin',
TechnicalCommittee: 'PalletCollectiveRawOrigin'
}
},
/**
* Lookup441: polkadot_runtime_common::claims::PrevalidateAttests<T>
**/
PolkadotRuntimeCommonClaimsPrevalidateAttests: 'Null',
/**
* Lookup442: polkadot_runtime::Runtime
**/
PolkadotRuntimeRuntime: 'Null'
} as DefinitionsTypes;
packages/types/src/augment/lookup/substrate.ts
+1462
View File
File diff suppressed because it is too large Load Diff
packages/types/src/augment/lookup/types-kusama.ts
+1324
View File
File diff suppressed because it is too large Load Diff
packages/types/src/augment/lookup/types-polkadot.ts
+99
View File
@@ -0,0 +1,99 @@
// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
/* eslint-disable */
import type { Compact, Enum, Null, Struct, U8aFixed, Vec, u16, u32 } from '@polkadot/types';
import type { PerU16 } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
declare module '@polkadot/types/lookup' {
/** @name PolkadotRuntimeCommonClaimsEthereumAddress (66) */
export interface PolkadotRuntimeCommonClaimsEthereumAddress extends U8aFixed {}
/** @name PolkadotRuntimeProxyType (72) */
export interface PolkadotRuntimeProxyType extends Enum {
readonly isAny: boolean;
readonly isNonTransfer: boolean;
readonly isGovernance: boolean;
readonly isStaking: boolean;
readonly isUnused4: boolean;
readonly isIdentityJudgement: boolean;
readonly isCancelProxy: boolean;
}
/** @name PolkadotRuntimeSessionKeys (139) */
export interface PolkadotRuntimeSessionKeys extends Struct {
readonly grandpa: SpFinalityGrandpaAppPublic;
readonly babe: SpConsensusBabeAppPublic;
readonly imOnline: PalletImOnlineSr25519AppSr25519Public;
readonly paraValidator: PolkadotPrimitivesV0ValidatorAppPublic;
readonly paraAssignment: PolkadotPrimitivesV1AssignmentAppPublic;
readonly authorityDiscovery: SpAuthorityDiscoveryAppPublic;
}
/** @name PolkadotPrimitivesV0ValidatorAppPublic (140) */
export interface PolkadotPrimitivesV0ValidatorAppPublic extends SpCoreSr25519Public {}
/** @name PolkadotPrimitivesV1AssignmentAppPublic (141) */
export interface PolkadotPrimitivesV1AssignmentAppPublic extends SpCoreSr25519Public {}
/** @name PolkadotRuntimeCommonClaimsEcdsaSignature (175) */
export interface PolkadotRuntimeCommonClaimsEcdsaSignature extends U8aFixed {}
/** @name PolkadotRuntimeCommonClaimsStatementKind (180) */
export interface PolkadotRuntimeCommonClaimsStatementKind extends Enum {
readonly isRegular: boolean;
readonly isSaft: boolean;
}
/** @name PolkadotRuntimeNposCompactSolution16 (233) */
export interface PolkadotRuntimeNposCompactSolution16 extends Struct {
readonly votes1: Vec<ITuple<[Compact<u32>, Compact<u16>]>>;
readonly votes2: Vec<ITuple<[Compact<u32>, ITuple<[Compact<u16>, Compact<PerU16>]>, Compact<u16>]>>;
readonly votes3: Vec<ITuple<[Compact<u32>, Vec<ITuple<[Compact<u16>, Compact<PerU16>]>>, Compact<u16>]>>;
readonly votes4: Vec<ITuple<[Compact<u32>, Vec<ITuple<[Compact<u16>, Compact<PerU16>]>>, Compact<u16>]>>;
readonly votes5: Vec<ITuple<[Compact<u32>, Vec<ITuple<[Compact<u16>, Compact<PerU16>]>>, Compact<u16>]>>;
readonly votes6: Vec<ITuple<[Compact<u32>, Vec<ITuple<[Compact<u16>, Compact<PerU16>]>>, Compact<u16>]>>;
readonly votes7: Vec<ITuple<[Compact<u32>, Vec<ITuple<[Compact<u16>, Compact<PerU16>]>>, Compact<u16>]>>;
readonly votes8: Vec<ITuple<[Compact<u32>, Vec<ITuple<[Compact<u16>, Compact<PerU16>]>>, Compact<u16>]>>;
readonly votes9: Vec<ITuple<[Compact<u32>, Vec<ITuple<[Compact<u16>, Compact<PerU16>]>>, Compact<u16>]>>;
readonly votes10: Vec<ITuple<[Compact<u32>, Vec<ITuple<[Compact<u16>, Compact<PerU16>]>>, Compact<u16>]>>;
readonly votes11: Vec<ITuple<[Compact<u32>, Vec<ITuple<[Compact<u16>, Compact<PerU16>]>>, Compact<u16>]>>;
readonly votes12: Vec<ITuple<[Compact<u32>, Vec<ITuple<[Compact<u16>, Compact<PerU16>]>>, Compact<u16>]>>;
readonly votes13: Vec<ITuple<[Compact<u32>, Vec<ITuple<[Compact<u16>, Compact<PerU16>]>>, Compact<u16>]>>;
readonly votes14: Vec<ITuple<[Compact<u32>, Vec<ITuple<[Compact<u16>, Compact<PerU16>]>>, Compact<u16>]>>;
readonly votes15: Vec<ITuple<[Compact<u32>, Vec<ITuple<[Compact<u16>, Compact<PerU16>]>>, Compact<u16>]>>;
readonly votes16: Vec<ITuple<[Compact<u32>, Vec<ITuple<[Compact<u16>, Compact<PerU16>]>>, Compact<u16>]>>;
}
/** @name PolkadotRuntimeOriginCaller (290) */
export interface PolkadotRuntimeOriginCaller extends Enum {
readonly isSystem: boolean;
readonly asSystem: FrameSystemRawOrigin;
readonly isUnused1: boolean;
readonly isUnused2: boolean;
readonly isVoid: boolean;
readonly isUnused4: boolean;
readonly isUnused5: boolean;
readonly isUnused6: boolean;
readonly isUnused7: boolean;
readonly isUnused8: boolean;
readonly isUnused9: boolean;
readonly isUnused10: boolean;
readonly isUnused11: boolean;
readonly isUnused12: boolean;
readonly isUnused13: boolean;
readonly isUnused14: boolean;
readonly isCouncil: boolean;
readonly asCouncil: PalletCollectiveRawOrigin;
readonly isTechnicalCommittee: boolean;
readonly asTechnicalCommittee: PalletCollectiveRawOrigin;
}
/** @name PolkadotRuntimeCommonClaimsPrevalidateAttests (441) */
export type PolkadotRuntimeCommonClaimsPrevalidateAttests = Null;
/** @name PolkadotRuntimeRuntime (442) */
export type PolkadotRuntimeRuntime = Null;
}
packages/types/src/augment/lookup/types-substrate.ts
+1464
View File
File diff suppressed because it is too large Load Diff
packages/types/src/augment/lookup/types.ts
+6
View File
@@ -0,0 +1,6 @@
// Copyright 2017-2021 @polkadot/types authors & contributors
// SPDX-License-Identifier: Apache-2.0
import './types-substrate';
import './types-polkadot';
import './types-kusama';
packages/types/src/augment/registry.ts
+1 -4
View File
@@ -32,7 +32,7 @@ import type { AuthorityIndex, AuthorityList, AuthoritySet, AuthoritySetChange, A
import type { IdentityFields, IdentityInfo, IdentityInfoAdditional, IdentityInfoTo198, IdentityJudgement, RegistrarIndex, RegistrarInfo, Registration, RegistrationJudgement, RegistrationTo198 } from '@polkadot/types/interfaces/identity';
import type { AuthIndex, AuthoritySignature, Heartbeat, HeartbeatTo244, OpaqueMultiaddr, OpaqueNetworkState, OpaquePeerId } from '@polkadot/types/interfaces/imOnline';
import type { CallIndex, LotteryConfig } from '@polkadot/types/interfaces/lottery';
import type { ErrorMetadataLatest, ErrorMetadataV10, ErrorMetadataV11, ErrorMetadataV12, ErrorMetadataV13, ErrorMetadataV14, ErrorMetadataV9, EventMetadataLatest, EventMetadataV10, EventMetadataV11, EventMetadataV12, EventMetadataV13, EventMetadataV14, EventMetadataV9, ExtrinsicMetadataLatest, ExtrinsicMetadataV11, ExtrinsicMetadataV12, ExtrinsicMetadataV13, ExtrinsicMetadataV14, FunctionArgumentMetadataLatest, FunctionArgumentMetadataV10, FunctionArgumentMetadataV11, FunctionArgumentMetadataV12, FunctionArgumentMetadataV13, FunctionArgumentMetadataV14, FunctionArgumentMetadataV9, FunctionMetadataLatest, FunctionMetadataV10, FunctionMetadataV11, FunctionMetadataV12, FunctionMetadataV13, FunctionMetadataV14, FunctionMetadataV9, MetadataAll, MetadataLatest, MetadataV10, MetadataV11, MetadataV12, MetadataV13, MetadataV14, MetadataV9, ModuleConstantMetadataLatest, ModuleConstantMetadataV10, ModuleConstantMetadataV11, ModuleConstantMetadataV12, ModuleConstantMetadataV13, ModuleConstantMetadataV9, ModuleMetadataLatest, ModuleMetadataV10, ModuleMetadataV11, ModuleMetadataV12, ModuleMetadataV13, ModuleMetadataV9, PalletCallMetadataLatest, PalletCallMetadataV14, PalletConstantMetadataLatest, PalletConstantMetadataV14, PalletErrorMetadataLatest, PalletErrorMetadataV14, PalletEventMetadataLatest, PalletEventMetadataV14, PalletMetadataLatest, PalletMetadataV14, PalletStorageMetadataLatest, PalletStorageMetadataV14, PortableRegistry, PortableType, SignedExtensionMetadataLatest, SignedExtensionMetadataV14, StorageEntryMetadataLatest, StorageEntryMetadataV10, StorageEntryMetadataV11, StorageEntryMetadataV12, StorageEntryMetadataV13, StorageEntryMetadataV14, StorageEntryMetadataV9, StorageEntryModifierLatest, StorageEntryModifierV10, StorageEntryModifierV11, StorageEntryModifierV12, StorageEntryModifierV13, StorageEntryModifierV14, StorageEntryModifierV9, StorageEntryTypeLatest, StorageEntryTypeV10, StorageEntryTypeV11, StorageEntryTypeV12, StorageEntryTypeV13, StorageEntryTypeV14, StorageEntryTypeV9, StorageHasher, StorageHasherV10, StorageHasherV11, StorageHasherV12, StorageHasherV13, StorageHasherV14, StorageHasherV9, StorageMetadataLatest, StorageMetadataV10, StorageMetadataV11, StorageMetadataV12, StorageMetadataV13, StorageMetadataV9 } from '@polkadot/types/interfaces/metadata';
import type { ErrorMetadataLatest, ErrorMetadataV10, ErrorMetadataV11, ErrorMetadataV12, ErrorMetadataV13, ErrorMetadataV14, ErrorMetadataV9, EventMetadataLatest, EventMetadataV10, EventMetadataV11, EventMetadataV12, EventMetadataV13, EventMetadataV14, EventMetadataV9, ExtrinsicMetadataLatest, ExtrinsicMetadataV11, ExtrinsicMetadataV12, ExtrinsicMetadataV13, ExtrinsicMetadataV14, FunctionArgumentMetadataLatest, FunctionArgumentMetadataV10, FunctionArgumentMetadataV11, FunctionArgumentMetadataV12, FunctionArgumentMetadataV13, FunctionArgumentMetadataV14, FunctionArgumentMetadataV9, FunctionMetadataLatest, FunctionMetadataV10, FunctionMetadataV11, FunctionMetadataV12, FunctionMetadataV13, FunctionMetadataV14, FunctionMetadataV9, MetadataAll, MetadataLatest, MetadataV10, MetadataV11, MetadataV12, MetadataV13, MetadataV14, MetadataV9, ModuleConstantMetadataV10, ModuleConstantMetadataV11, ModuleConstantMetadataV12, ModuleConstantMetadataV13, ModuleConstantMetadataV9, ModuleMetadataV10, ModuleMetadataV11, ModuleMetadataV12, ModuleMetadataV13, ModuleMetadataV9, PalletCallMetadataLatest, PalletCallMetadataV14, PalletConstantMetadataLatest, PalletConstantMetadataV14, PalletErrorMetadataLatest, PalletErrorMetadataV14, PalletEventMetadataLatest, PalletEventMetadataV14, PalletMetadataLatest, PalletMetadataV14, PalletStorageMetadataLatest, PalletStorageMetadataV14, PortableRegistry, PortableType, SignedExtensionMetadataLatest, SignedExtensionMetadataV14, StorageEntryMetadataLatest, StorageEntryMetadataV10, StorageEntryMetadataV11, StorageEntryMetadataV12, StorageEntryMetadataV13, StorageEntryMetadataV14, StorageEntryMetadataV9, StorageEntryModifierLatest, StorageEntryModifierV10, StorageEntryModifierV11, StorageEntryModifierV12, StorageEntryModifierV13, StorageEntryModifierV14, StorageEntryModifierV9, StorageEntryTypeLatest, StorageEntryTypeV10, StorageEntryTypeV11, StorageEntryTypeV12, StorageEntryTypeV13, StorageEntryTypeV14, StorageEntryTypeV9, StorageHasher, StorageHasherV10, StorageHasherV11, StorageHasherV12, StorageHasherV13, StorageHasherV14, StorageHasherV9, StorageMetadataV10, StorageMetadataV11, StorageMetadataV12, StorageMetadataV13, StorageMetadataV9 } from '@polkadot/types/interfaces/metadata';
import type { MmrLeafProof } from '@polkadot/types/interfaces/mmr';
import type { StorageKind } from '@polkadot/types/interfaces/offchain';
import type { DeferredOffenceOf, Kind, OffenceDetails, Offender, OpaqueTimeSlot, ReportIdOf, Reporter } from '@polkadot/types/interfaces/offences';
@@ -540,14 +540,12 @@ declare module '@polkadot/types/types/registry' {
MetadataV9: MetadataV9;
MmrLeafProof: MmrLeafProof;
MmrRootHash: MmrRootHash;
ModuleConstantMetadataLatest: ModuleConstantMetadataLatest;
ModuleConstantMetadataV10: ModuleConstantMetadataV10;
ModuleConstantMetadataV11: ModuleConstantMetadataV11;
ModuleConstantMetadataV12: ModuleConstantMetadataV12;
ModuleConstantMetadataV13: ModuleConstantMetadataV13;
ModuleConstantMetadataV9: ModuleConstantMetadataV9;
ModuleId: ModuleId;
ModuleMetadataLatest: ModuleMetadataLatest;
ModuleMetadataV10: ModuleMetadataV10;
ModuleMetadataV11: ModuleMetadataV11;
ModuleMetadataV12: ModuleMetadataV12;
@@ -894,7 +892,6 @@ declare module '@polkadot/types/types/registry' {
StorageHasherV9: StorageHasherV9;
StorageKey: StorageKey;
StorageKind: StorageKind;
StorageMetadataLatest: StorageMetadataLatest;
StorageMetadataV10: StorageMetadataV10;
StorageMetadataV11: StorageMetadataV11;
StorageMetadataV12: StorageMetadataV12;
packages/types/src/codec/BTreeSet.ts
+2 -2
View File
@@ -20,10 +20,10 @@ function decodeSetFromU8a<V extends Codec> (registry: Registry, ValClass: Constr
types.push(ValClass);
}
const values = decodeU8a(registry, u8a.subarray(offset), types);
const values = decodeU8a<V>(registry, u8a.subarray(offset), types);
for (let i = 0; i < values.length; i++) {
output.add(values[i] as V);
output.add(values[i]);
}
return output;
packages/types/src/codec/Struct.ts
+9 -8
View File
@@ -24,22 +24,23 @@ function decodeStructFromObject <T> (registry: Registry, Types: ConstructorDef,
const jsonKey = (jsonMap.get(key as any) && !value[key])
? jsonMap.get(key as any)
: key;
const Type = Types[key];
try {
if (Array.isArray(value)) {
// TS2322: Type 'Codec' is not assignable to type 'T[keyof S]'.
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
(raw as any)[key] = value[index] instanceof Types[key]
(raw as any)[key] = value[index] instanceof Type
? value[index]
: new Types[key](registry, value[index]);
: new Type(registry, value[index]);
} else if (value instanceof Map) {
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
const mapped = value.get(jsonKey);
// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
(raw as any)[key] = mapped instanceof Types[key]
(raw as any)[key] = mapped instanceof Type
? mapped
: new Types[key](registry, mapped);
: new Type(registry, mapped);
} else if (isObject(value)) {
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
let assign = value[jsonKey as string];
@@ -59,17 +60,17 @@ function decodeStructFromObject <T> (registry: Registry, Types: ConstructorDef,
}
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
(raw as any)[key] = assign instanceof Types[key]
(raw as any)[key] = assign instanceof Type
? assign
: new Types[key](registry, assign);
: new Type(registry, assign);
} else {
throw new Error(`Cannot decode value ${stringify(value)} (typeof ${typeof value}), expected an input object with known keys`);
}
} catch (error) {
let type = Types[key].name;
let type = Type.name;
try {
type = new Types[key](registry).toRawType();
type = new Type(registry).toRawType();
} catch (error) {
// ignore
}
packages/types/src/codec/Tuple.ts
+1 -1
View File
@@ -86,7 +86,7 @@ export class Tuple extends AbstractArray<Codec> implements ITuple<Codec[]> {
*/
public get Types (): string[] {
return Array.isArray(this._Types)
? this._Types.map((Type): string => new Type(this.registry).toRawType())
? this._Types.map((Type) => new Type(this.registry).toRawType())
: Object.keys(this._Types);
}
packages/types/src/codec/Vec.ts
+1 -1
View File
@@ -52,7 +52,7 @@ export class Vec<T extends Codec> extends AbstractArray<T> {
assert(length.lten(MAX_LENGTH), () => `Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
return decodeU8a(registry, u8a.subarray(offset), new Array(length.toNumber()).fill(Type)) as T[];
return decodeU8a(registry, u8a.subarray(offset), new Array(length.toNumber()).fill(Type));
}
public static with<O extends Codec> (Type: Constructor<O> | string): Constructor<Vec<O>> {
packages/types/src/codec/utils/decodeU8a.ts
+5 -4
View File
@@ -10,13 +10,14 @@ import { u8aToHex } from '@polkadot/util';
* types, and return an array of decoded values.
*
* @param u8a - The u8a to decode.
* @param result - The result array (will be returned with values pushed)
* @param types - The array of Constructor to decode the U8a against.
*/
export function decodeU8a (registry: Registry, u8a: Uint8Array, _types: Constructor[] | { [index: string]: Constructor }, _keys?: string[]): Codec[] {
const [types, keys]: [Constructor<Codec>[], string[]] = Array.isArray(_types)
export function decodeU8a <T extends Codec = Codec> (registry: Registry, u8a: Uint8Array, _types: Constructor[] | { [index: string]: Constructor }, _keys?: string[]): T[] {
const result: T[] = [];
const [types, keys]: [Constructor[], string[]] = Array.isArray(_types)
? [_types, _keys || []]
: [Object.values(_types), Object.keys(_types)];
const result: Codec[] = [];
let offset = 0;
for (let i = 0; i < types.length; i++) {
@@ -25,7 +26,7 @@ export function decodeU8a (registry: Registry, u8a: Uint8Array, _types: Construc
try {
const value = new Type(registry, u8a.subarray(offset));
result.push(value);
result.push(value as T);
offset += value.encodedLength;
} catch (error) {
let rawType: string;
packages/types/src/codec/utils/typeToConstructor.ts
+1 -1
View File
@@ -5,7 +5,7 @@ import type { Codec, Constructor, Registry } from '../../types';
import { isString } from '@polkadot/util';
export function typeToConstructor <T = Codec> (registry: Registry, type: string | Constructor<T>): Constructor<T> {
export function typeToConstructor <T extends Codec = Codec> (registry: Registry, type: string | Constructor<T>): Constructor<T> {
return (
isString(type)
? registry.createClass(type)
packages/types/src/create/createClass.spec.ts
+5 -1
View File
@@ -29,7 +29,11 @@ describe('getTypeClass', (): void => {
const spy = jest.spyOn(console, 'warn');
const typeDef = { info: TypeDefInfo.Plain, type: 'ABC' };
getTypeClass(registry, typeDef);
try {
getTypeClass(registry, typeDef);
} catch {
// ignore
}
expect(spy).toHaveBeenCalledWith(
expect.anything(),
packages/types/src/create/encodeTypes.ts
+58 -84
View File
@@ -32,17 +32,12 @@ function encodeWithParams (registry: Registry, typeDef: TypeDef, outer: string):
case TypeDefInfo.Option:
case TypeDefInfo.Result:
case TypeDefInfo.Vec:
return paramsNotation(outer, sub, (param) => encodeTypeDef(registry, param));
return paramsNotation(outer, sub, (p) => encodeTypeDef(registry, p));
}
throw new Error(`Unable to encode ${stringify(typeDef)} with params`);
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
function encodeDoNotConstruct (registry: Registry, { displayName }: TypeDef): string {
return `DoNotConstruct<${displayName || 'Unknown'}>`;
}
function encodeSubTypes (registry: Registry, sub: TypeDef[], asEnum?: boolean, extra?: Record<string, unknown>): string {
const names = sub.map(({ name }) => name);
@@ -60,52 +55,6 @@ function encodeSubTypes (registry: Registry, sub: TypeDef[], asEnum?: boolean, e
);
}
function encodeEnum (registry: Registry, typeDef: TypeDef): string {
assert(typeDef.sub && Array.isArray(typeDef.sub), 'Unable to encode Enum type');
const sub = typeDef.sub;
// c-like enums have all Null entries
// TODO We need to take the disciminant into account and auto-add empty entries
return sub.every(({ type }) => type === 'Null')
? stringify({ _enum: sub.map(({ name }, index) => `${name || `Empty${index}`}`) })
: encodeSubTypes(registry, sub, true);
}
function encodeStruct (registry: Registry, typeDef: TypeDef): string {
assert(typeDef.sub && Array.isArray(typeDef.sub), 'Unable to encode Struct type');
return encodeSubTypes(registry, typeDef.sub, false, {
...(
typeDef.alias
? { _alias: [...typeDef.alias.entries()].reduce<Record<string, string>>((all, [k, v]) => ({
...all,
[k]: v
}), {}) }
: {}
)
});
}
function encodeTuple (registry: Registry, typeDef: TypeDef): string {
assert(typeDef.sub && Array.isArray(typeDef.sub), 'Unable to encode Tuple type');
return `(${typeDef.sub.map((type) => encodeTypeDef(registry, type)).join(',')})`;
}
function encodeUInt (registry: Registry, { length }: TypeDef, type: 'Int' | 'UInt'): string {
assert(isNumber(length), 'Unable to encode VecFixed type');
return `${type}<${length}>`;
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
function encodeVecFixed (registry: Registry, { length, sub }: TypeDef): string {
assert(isNumber(length) && !isUndefined(sub) && !Array.isArray(sub), 'Unable to encode VecFixed type');
return `[${sub.type};${length}]`;
}
// We setup a record here to ensure we have comprehensive coverage (any item not covered will result
// in a compile-time error with the missing index)
const encoders: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef) => string> = {
@@ -115,14 +64,21 @@ const encoders: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef) => st
encodeWithParams(registry, typeDef, 'BTreeSet'),
[TypeDefInfo.Compact]: (registry: Registry, typeDef: TypeDef) =>
encodeWithParams(registry, typeDef, 'Compact'),
[TypeDefInfo.DoNotConstruct]: (registry: Registry, typeDef: TypeDef) =>
encodeDoNotConstruct(registry, typeDef),
[TypeDefInfo.Enum]: (registry: Registry, typeDef: TypeDef) =>
encodeEnum(registry, typeDef),
[TypeDefInfo.DoNotConstruct]: (registry: Registry, { displayName, lookupIndex, lookupName }: TypeDef) =>
`DoNotConstruct<${lookupName || displayName || (isUndefined(lookupIndex) ? 'Unknown' : registry.createLookupType(lookupIndex))}>`,
[TypeDefInfo.Enum]: (registry: Registry, { sub }: TypeDef): string => {
assert(sub && Array.isArray(sub), 'Unable to encode Enum type');
// c-like enums have all Null entries
// TODO We need to take the disciminant into account and auto-add empty entries
return sub.every(({ type }) => type === 'Null')
? stringify({ _enum: sub.map(({ name }, index) => `${name || `Empty${index}`}`) })
: encodeSubTypes(registry, sub, true);
},
[TypeDefInfo.HashMap]: (registry: Registry, typeDef: TypeDef) =>
encodeWithParams(registry, typeDef, 'HashMap'),
[TypeDefInfo.Int]: (registry: Registry, typeDef: TypeDef) =>
encodeUInt(registry, typeDef, 'Int'),
[TypeDefInfo.Int]: (registry: Registry, { length = 32 }: TypeDef) =>
`Int<${length}>`,
[TypeDefInfo.Linkage]: (registry: Registry, typeDef: TypeDef) =>
encodeWithParams(registry, typeDef, 'Linkage'),
// eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -131,51 +87,69 @@ const encoders: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef) => st
[TypeDefInfo.Option]: (registry: Registry, typeDef: TypeDef) =>
encodeWithParams(registry, typeDef, 'Option'),
// eslint-disable-next-line @typescript-eslint/no-unused-vars
[TypeDefInfo.Plain]: (registry: Registry, typeDef: TypeDef) =>
typeDef.displayName || typeDef.type,
[TypeDefInfo.Plain]: (registry: Registry, { displayName, type }: TypeDef) =>
displayName || type,
[TypeDefInfo.Range]: (registry: Registry, typeDef: TypeDef) =>
encodeWithParams(registry, typeDef, typeDef.type.includes('RangeInclusive') ? 'RangeInclusive' : 'Range'),
[TypeDefInfo.Result]: (registry: Registry, typeDef: TypeDef) =>
encodeWithParams(registry, typeDef, 'Result'),
// eslint-disable-next-line @typescript-eslint/no-unused-vars
[TypeDefInfo.Set]: (registry: Registry, typeDef: TypeDef) =>
typeDef.type,
[TypeDefInfo.Set]: (registry: Registry, { length = 8, sub }: TypeDef): string => {
assert(sub && Array.isArray(sub), 'Unable to encode Set type');
return stringify({
_set: sub.reduce((all, { index, name }, count): Record<string, number> => ({
...all,
[`${name || `Unknown${index || count}`}`]: index || count
}), { _bitLength: length || 8 } as Record<string, number>)
});
},
// eslint-disable-next-line @typescript-eslint/no-unused-vars
[TypeDefInfo.Si]: (registry: Registry, typeDef: TypeDef) =>
typeDef.lookupName || typeDef.type,
[TypeDefInfo.Struct]: (registry: Registry, typeDef: TypeDef) =>
encodeStruct(registry, typeDef),
[TypeDefInfo.Tuple]: (registry: Registry, typeDef: TypeDef) =>
encodeTuple(registry, typeDef),
[TypeDefInfo.UInt]: (registry: Registry, typeDef: TypeDef) =>
encodeUInt(registry, typeDef, 'UInt'),
[TypeDefInfo.Si]: (registry: Registry, { lookupName, type }: TypeDef) =>
lookupName || type,
[TypeDefInfo.Struct]: (registry: Registry, { alias, sub }: TypeDef): string => {
assert(sub && Array.isArray(sub), 'Unable to encode Struct type');
return encodeSubTypes(registry, sub, false, {
...(
alias
? { _alias: [...alias.entries()].reduce<Record<string, string>>((all, [k, v]) => ({
...all,
[k]: v
}), {}) }
: {}
)
});
},
[TypeDefInfo.Tuple]: (registry: Registry, { sub }: TypeDef): string => {
assert(sub && Array.isArray(sub), 'Unable to encode Tuple type');
return `(${sub.map((type) => encodeTypeDef(registry, type)).join(',')})`;
},
[TypeDefInfo.UInt]: (registry: Registry, { length = 32 }: TypeDef) =>
`UInt<${length}>`,
[TypeDefInfo.Vec]: (registry: Registry, typeDef: TypeDef) =>
encodeWithParams(registry, typeDef, 'Vec'),
[TypeDefInfo.VecFixed]: (registry: Registry, typeDef: TypeDef) =>
encodeVecFixed(registry, typeDef)
[TypeDefInfo.VecFixed]: (registry: Registry, { length, sub }: TypeDef): string => {
assert(isNumber(length) && !isUndefined(sub) && !Array.isArray(sub), 'Unable to encode VecFixed type');
return `[${sub.type};${length}]`;
}
};
function encodeType (registry: Registry, typeDef: TypeDef, withLookup = true): string {
const encoder = encoders[typeDef.info];
assert(encoder, () => `Cannot encode type ${stringify(typeDef)}`);
return withLookup && typeDef.lookupName
? typeDef.lookupName
: encoder(registry, typeDef);
: encoders[typeDef.info](registry, typeDef);
}
export function encodeTypeDef (registry: Registry, typeDef: TypeDef): string {
assert(!isUndefined(typeDef.info), () => `Invalid type definition with no instance info, typeDef=${stringify(typeDef)}`);
// In the case of contracts we do have the unfortunate situation where the displayName would
// refer to "Option" when it is an option. For these, string it out, only using when actually
// not a top-level element to be used
if (typeDef.displayName && !INFO_WRAP.some((i) => typeDef.displayName === i)) {
return typeDef.displayName;
}
return encodeType(registry, typeDef);
return (typeDef.displayName && !INFO_WRAP.some((i) => typeDef.displayName === i))
? typeDef.displayName
: encodeType(registry, typeDef);
}
export function withTypeString (registry: Registry, typeDef: Omit<TypeDef, 'type'>): TypeDef {
packages/types/src/create/getTypeDef.ts
+1 -1
View File
@@ -79,7 +79,7 @@ function _decodeSet (value: TypeDef, details: Record<string, number>): TypeDef {
index,
info: TypeDefInfo.Plain,
name,
type: name
type: 'Null'
}));
return value;
packages/types/src/create/registry.ts
+47 -34
View File
@@ -1,8 +1,6 @@
// Copyright 2017-2021 @polkadot/types authors & contributors
// SPDX-License-Identifier: Apache-2.0
/* eslint-disable @typescript-eslint/no-var-requires */
import type { ExtDef } from '../extrinsic/signedExtensions/types';
import type { ChainProperties, CodecHash, DispatchErrorModule, Hash, MetadataLatest, PortableRegistry, SiLookupTypeId } from '../interfaces/types';
import type { CallFunction, Codec, CodecHasher, Constructor, DetectCodec, DetectConstructor, RegisteredTypes, Registry, RegistryError, RegistryTypes } from '../types';
@@ -20,29 +18,37 @@ import * as baseTypes from '../index.types';
import * as definitions from '../interfaces/definitions';
import { decorateConstants, decorateExtrinsics } from '../metadata/decorate';
import { Metadata } from '../metadata/Metadata';
import { createClass, getTypeClass } from './createClass';
import { createClass } from './createClass';
import { createTypeUnsafe } from './createType';
import { getTypeDef } from './getTypeDef';
const l = logger('registry');
// create error mapping from metadata
function injectErrors (_: Registry, metadata: Metadata, metadataErrors: Record<string, RegistryError>): void {
const modules = metadata.asLatest.modules;
const { lookup, pallets } = metadata.asLatest;
// decorate the errors
modules.forEach(({ errors, index, name }, _sectionIndex): void => {
pallets.forEach(({ errors, index, name }, _sectionIndex): void => {
if (errors.isNone) {
return;
}
const sectionIndex = metadata.version >= 12
? index.toNumber()
: _sectionIndex;
const sectionName = stringCamelCase(name);
errors.forEach(({ docs, name }, index): void => {
const eventIndex = new Uint8Array([sectionIndex, index]);
lookup.getSiType(errors.unwrap().type).def.asVariant.variants.forEach(({ docs, fields, index, name }): void => {
const variantIndex = index.toNumber();
const eventIndex = new Uint8Array([sectionIndex, variantIndex]);
metadataErrors[u8aToHex(eventIndex)] = {
args: fields.map(({ type }) =>
lookup.getTypeDef(type).type
),
docs: docs.map((d) => d.toString()),
index,
fields,
index: variantIndex,
method: name.toString(),
name: name.toString(),
section: sectionName
@@ -53,8 +59,10 @@ function injectErrors (_: Registry, metadata: Metadata, metadataErrors: Record<s
// create event classes from metadata
function injectEvents (registry: Registry, metadata: Metadata, metadataEvents: Record<string, Constructor<GenericEventData>>): void {
const { lookup, pallets } = metadata.asLatest;
// decorate the events
metadata.asLatest.modules
pallets
.filter(({ events }) => events.isSome)
.forEach(({ events, index, name }, _sectionIndex): void => {
const sectionIndex = metadata.version >= 12
@@ -62,23 +70,19 @@ function injectEvents (registry: Registry, metadata: Metadata, metadataEvents: R
: _sectionIndex;
const sectionName = stringCamelCase(name);
events.unwrap().forEach((meta, methodIndex): void => {
const methodName = meta.name.toString();
const typeDef = meta.args.map((arg) => getTypeDef(arg));
let Types: Constructor<Codec>[] | null = null;
lookup.getSiType(events.unwrap().type).def.asVariant.variants.forEach((variant): void => {
const variantIndex = variant.index.toNumber();
const eventIndex = new Uint8Array([sectionIndex, variantIndex]);
const meta = registry.createType('EventMetadataLatest', {
...variant,
args: variant.fields.map(({ type }) =>
lookup.getTypeDef(type).type
)
});
// Lazy create the actual type classes right at the point of use
const getTypes = (): Constructor<Codec>[] => {
if (!Types) {
Types = typeDef.map((typeDef) => getTypeClass(registry, typeDef));
}
return Types;
};
metadataEvents[u8aToHex(new Uint8Array([sectionIndex, methodIndex]))] = class extends GenericEventData {
metadataEvents[u8aToHex(eventIndex)] = class extends GenericEventData {
constructor (registry: Registry, value: Uint8Array) {
super(registry, value, getTypes(), typeDef, meta, sectionName, methodName);
super(registry, value, meta, sectionName, variant.name.toString());
}
};
});
@@ -219,9 +223,7 @@ export class TypeRegistry implements Registry {
}
public get lookup (): PortableRegistry {
throw new Error('Unimplemented');
// return this.metadata.lookup;
return this.metadata.lookup;
}
public get metadata (): MetadataLatest {
@@ -249,7 +251,7 @@ export class TypeRegistry implements Registry {
* @description Creates an instance of a type as registered
*/
public createType <T extends Codec = Codec, K extends string = string> (type: K, ...params: unknown[]): DetectCodec<T, K> {
return createTypeUnsafe(this, type, params);
return this.createTypeUnsafe(type, params);
}
/**
@@ -271,7 +273,10 @@ export class TypeRegistry implements Registry {
const hexIndex = u8aToHex(
isU8a(errorIndex)
? errorIndex
: new Uint8Array([errorIndex.index.toNumber(), errorIndex.error.toNumber()])
: new Uint8Array([
errorIndex.index.toNumber(),
errorIndex.error.toNumber()
])
);
return assertReturn(this.#metadataErrors[hexIndex], `findMetaError: Unable to find Error with index ${hexIndex}/[${errorIndex.toString()}]`);
@@ -294,10 +299,13 @@ export class TypeRegistry implements Registry {
// we have a definition, so create the class now (lazily)
if (definition) {
BaseType = createClass(this, definition);
this.#classes.set(name, BaseType);
} else if (withUnknown) {
l.warn(`Unable to resolve type ${name}, it will fail on construction`);
this.#unknownTypes.set(name, true);
BaseType = DoNotConstruct.with(name);
}
@@ -318,8 +326,8 @@ export class TypeRegistry implements Registry {
return this.#chainProperties;
}
public getClassName (clazz: Constructor): string | undefined {
const entry = [...this.#classes.entries()].find(([, test]) => test === clazz);
public getClassName (Type: Constructor): string | undefined {
const entry = [...this.#classes.entries()].find(([, Clazz]) => Type === Clazz);
return entry
? entry[0]
@@ -335,7 +343,11 @@ export class TypeRegistry implements Registry {
}
public getOrThrow <T extends Codec = Codec, K extends string = string> (name: K, msg?: string): DetectConstructor<T, K> {
return assertReturn(this.get<T, K>(name), msg || `type ${name} not found`);
const Clazz = this.get<T, K>(name);
assert(Clazz, msg || `type ${name} not found`);
return Clazz;
}
public getOrUnknown <T extends Codec = Codec, K extends string = string> (name: K): DetectConstructor<T, K> {
@@ -435,7 +447,8 @@ export class TypeRegistry implements Registry {
this.setSignedExtensions(
signedExtensions || (
metadata.asLatest.extrinsic.version.gt(BN_ZERO)
? metadata.asLatest.extrinsic.signedExtensions.map((key) => key.toString())
// FIXME Use the extension and their injected types
? metadata.asLatest.extrinsic.signedExtensions.map(({ identifier }) => identifier.toString())
: fallbackExtensions
),
userExtensions
packages/types/src/extrinsic/Extrinsic.spec.ts
+1 -1
View File
@@ -39,7 +39,7 @@ describe('Extrinsic', (): void => {
expect(extrinsic.tip.toHuman()).toEqual('30.0000 mUnit');
expect(extrinsic.callIndex).toEqual(new Uint8Array([6, 0]));
expect(extrinsic.args[0].toHex()).toEqual('0x00495e1e506f266418af07fa0c5c108dd436f2faa59fe7d9e54403779f5bbd7718');
expect(extrinsic.args[1].toHuman()).toEqual('104.5609 Unit');
expect(extrinsic.args[1].toHuman()).toEqual('104,560,923,320,000'); // ('104.5609 Unit');
});
});
});
packages/types/src/extrinsic/Extrinsic.ts
+1 -1
View File
@@ -2,7 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
import type { EcdsaSignature, Ed25519Signature, ExtrinsicUnknown, ExtrinsicV4, Sr25519Signature } from '../interfaces/extrinsics';
import type { FunctionMetadataLatest } from '../interfaces/metadata/types';
import type { FunctionMetadataLatest } from '../interfaces/metadata';
import type { Address, Balance, Call, Index } from '../interfaces/runtime';
import type { AnyJson, AnyTuple, AnyU8a, ArgsDef, CallBase, ExtrinsicPayloadValue, IExtrinsic, IKeyringPair, IMethod, Registry, SignatureOptions } from '../types';
import type { GenericExtrinsicEra } from './ExtrinsicEra';
packages/types/src/generic/Call.ts
+4 -19
View File
@@ -1,15 +1,13 @@
// Copyright 2017-2021 @polkadot/types authors & contributors
// SPDX-License-Identifier: Apache-2.0
import type { FunctionArgumentMetadataLatest, FunctionMetadataLatest } from '../interfaces/metadata';
import type { AnyJson, AnyTuple, AnyU8a, ArgsDef, CallBase, CallFunction, IMethod, Registry } from '../types';
import type { FunctionMetadataLatest } from '../interfaces/metadata';
import type { AnyJson, AnyTuple, AnyU8a, ArgsDef, CallBase, CallFunction, IMethod, InterfaceTypes, Registry } from '../types';
import { isHex, isObject, isU8a, u8aToU8a } from '@polkadot/util';
import { Struct } from '../codec/Struct';
import { U8aFixed } from '../codec/U8aFixed';
import { getTypeClass } from '../create/createClass';
import { getTypeDef } from '../create/getTypeDef';
interface DecodeMethodInput {
args: unknown;
@@ -30,11 +28,8 @@ interface DecodedMethod extends DecodeMethodInput {
* @internal
*/
function getArgsDef (registry: Registry, meta: FunctionMetadataLatest): ArgsDef {
// eslint-disable-next-line @typescript-eslint/no-use-before-define
return GenericCall.filterOrigin(meta).reduce((result, { name, type }): ArgsDef => {
const Type = getTypeClass(registry, getTypeDef(type));
result[name.toString()] = Type;
return meta.fields.reduce((result, { name, type }, index): ArgsDef => {
result[name.unwrapOr(`param${index}`).toString()] = registry.createLookupType(type) as keyof InterfaceTypes;
return result;
}, {} as ArgsDef);
@@ -146,16 +141,6 @@ export class GenericCall<A extends AnyTuple = AnyTuple> extends Struct implement
this._meta = decoded.meta;
}
// If the extrinsic function has an argument of type `Origin`, we ignore it
public static filterOrigin (meta?: FunctionMetadataLatest): FunctionArgumentMetadataLatest[] {
// FIXME should be `arg.type !== Origin`, but doesn't work...
return meta
? meta.args.filter(({ type }): boolean =>
type.toString() !== 'Origin'
)
: [];
}
/**
* @description The arguments for the function call
*/
packages/types/src/generic/Event.ts
+6 -4
View File
@@ -4,7 +4,7 @@
import type { TypeDef } from '../create/types';
import type { EventMetadataLatest } from '../interfaces/metadata';
import type { EventId } from '../interfaces/system';
import type { AnyJson, Codec, Constructor, IEvent, IEventData, Registry } from '../types';
import type { AnyJson, Codec, Constructor, IEvent, IEventData, InterfaceTypes, Registry } from '../types';
import { Struct } from '../codec/Struct';
import { Tuple } from '../codec/Tuple';
@@ -49,13 +49,15 @@ export class GenericEventData extends Tuple implements IEventData {
readonly #typeDef: TypeDef[];
constructor (registry: Registry, value: Uint8Array, Types: Constructor[] = [], typeDef: TypeDef[] = [], meta: EventMetadataLatest, section = '<unknown>', method = '<unknown>') {
super(registry, Types, value);
constructor (registry: Registry, value: Uint8Array, meta: EventMetadataLatest, section = '<unknown>', method = '<unknown>') {
const fields = meta?.fields || [];
super(registry, fields.map(({ type }) => registry.createLookupType(type) as keyof InterfaceTypes), value);
this.#meta = meta;
this.#method = method;
this.#section = section;
this.#typeDef = typeDef;
this.#typeDef = fields.map(({ type }) => registry.lookup.getTypeDef(type));
}
/**
packages/types/src/generic/PortableRegistry.ts
+121 -34
View File
@@ -15,6 +15,9 @@ import { withTypeString } from '../create/encodeTypes';
import { getTypeDef } from '../create/getTypeDef';
import { TypeDefInfo } from '../types';
// Just a placeholder for a type.unrwapOr()
const TYPE_UNWRAP = { toNumber: () => -1 };
// Alias the primitive enum with out known values
const PRIMITIVE_ALIAS: Record<string, string> = {
Char: 'u32', // Rust char is 4-bytes
@@ -72,26 +75,96 @@ function getPrimitivePath (path: SiPath): string | null {
: null;
}
function removeDuplicateNames (names: [number, (string | null)][]): [number, (string | null)][] {
return names.map(([lookupIndex, name]): [number, string | null] => [
lookupIndex,
(
!name ||
names.some(([oIndex, oName]) =>
name === oName &&
lookupIndex !== oIndex
)
)
? null
: name
]);
function removeDuplicateNames (lookup: GenericPortableRegistry, names: [number, string | null, SiTypeParameter[]][]): [number, string][] {
const rewrite: Record<number, string> = {};
return names
.map(([lookupIndex, name, params]): [number, string | null] => {
if (!name) {
return [lookupIndex, null];
}
// those where the name is matching
const allSame = names.filter(([, oName]) => name === oName);
// are there among matching names
const anyDiff = allSame.some(([oIndex,, oParams]) =>
lookupIndex !== oIndex && (
params.length !== oParams.length ||
params.some((p, index) =>
!p.name.eq(oParams[index].name) ||
p.type.unwrapOr(TYPE_UNWRAP).toNumber() !== oParams[index].type.unwrapOr(TYPE_UNWRAP).toNumber()
)
)
);
// everything matches, we can combine these
if (!anyDiff || !allSame[0][2].length) {
return [lookupIndex, name];
}
// find the first parameter that yields differences
const paramIdx = allSame[0][2].findIndex(({ type }, index) =>
allSame.every(([,, params]) => params[index].type.isSome) &&
allSame.every(([,, params], aIndex) =>
aIndex === 0 ||
!params[index].type.eq(type)
)
);
// No param found that is different
if (paramIdx === -1) {
return [lookupIndex, name];
}
// see if using the param type helps
const adjusted = allSame.map(([oIndex, oName, oParams]): [number, string | null] => {
const { def, path } = lookup.getSiType(oParams[paramIdx].type.unwrap());
if (!def.isPrimitive && !path.length) {
return [oIndex, null];
}
return [
oIndex,
def.isPrimitive
? `${oName as string}${def.asPrimitive.toString()}`
: `${oName as string}${path[path.length - 1].toString()}`
];
});
// any dupes remaining?
const noDupes = adjusted.every(([i, n]) =>
!!n &&
!adjusted.some(([ai, an]) =>
i !== ai &&
n === an
)
);
if (noDupes) {
// we filtered above for null names
adjusted.forEach(([index, name]): void => {
rewrite[index] = name as string;
});
}
return noDupes
? [lookupIndex, name]
: [lookupIndex, null];
})
.filter((n): n is [number, string] => !!n[1])
.map(([lookupIndex, name]) => [
lookupIndex,
rewrite[lookupIndex] || name
]);
}
function extractName (types: PortableType[], id: SiLookupTypeId, { params, path }: SiType): [number, string | null] {
function extractName (types: PortableType[], { id, type: { params, path } }: PortableType): [number, string | null, SiTypeParameter[]] {
const lookupIndex = id.toNumber();
if (!path.length || WRAPPERS.includes(path[path.length - 1].toString())) {
return [lookupIndex, null];
return [lookupIndex, null, []];
}
const parts = path
@@ -120,28 +193,25 @@ function extractName (types: PortableType[], id: SiLookupTypeId, { params, path
}
}
return [lookupIndex, typeName];
return [lookupIndex, typeName, params];
}
function extractNames (registry: Registry, types: PortableType[]): Record<number, string> {
const dedup = removeDuplicateNames(
types.map(({ id, type }) =>
extractName(types, id, type)
)
);
const [names, typesNew] = dedup.reduce<[Record<number, string>, Record<string, string>]>(([names, types], [lookupIndex, name], index) => {
if (name) {
// We set the name for this specific type
names[index] = name;
function extractNames (lookup: GenericPortableRegistry, types: PortableType[]): Record<number, string> {
const dedup = removeDuplicateNames(lookup, types.map((t) =>
extractName(types, t)
));
// we map to the actual lookupIndex
types[name] = registry.createLookupType(lookupIndex);
}
const [names, typesNew] = dedup.reduce<[Record<number, string>, Record<string, string>]>(([names, types], [lookupIndex, name]) => {
// We set the name for this specific type
names[lookupIndex] = name;
// we map to the actual lookupIndex
types[name] = lookup.registry.createLookupType(lookupIndex);
return [names, types];
}, [{}, {}]);
registry.register(typesNew);
lookup.registry.register(typesNew);
return names;
}
@@ -155,7 +225,7 @@ export class GenericPortableRegistry extends Struct {
types: 'Vec<PortableType>'
}, value);
this.#names = extractNames(registry, this.types);
this.#names = extractNames(this, this.types);
}
/**
@@ -165,6 +235,13 @@ export class GenericPortableRegistry extends Struct {
return this.get('types') as Vec<PortableType>;
}
/**
* @description Returns the name for a specific lookup
*/
public getName (lookupId: SiLookupTypeId | string | number): string | undefined {
return this.#names[this.#getLookupId(lookupId)];
}
/**
* @description Finds a specific type in the registry
*/
@@ -183,16 +260,26 @@ export class GenericPortableRegistry extends Struct {
const lookupIndex = this.#getLookupId(lookupId);
if (!this.#typeDefs[lookupIndex]) {
// we set first since we will get into circular lookups along the way
this.#typeDefs[lookupIndex] = {
const lookupName = this.#names[lookupIndex];
const empty = {
info: TypeDefInfo.DoNotConstruct,
lookupIndex,
lookupName: this.#names[lookupIndex],
lookupName,
type: this.registry.createLookupType(lookupIndex)
};
// Set named items since we will get into circular lookups along the way
if (lookupName) {
this.#typeDefs[lookupIndex] = empty;
}
const extracted = this.#extract(this.getSiType(lookupId), lookupIndex);
// For non-named items, we only set this right at the end
if (!lookupName) {
this.#typeDefs[lookupIndex] = empty;
}
Object.keys(extracted).forEach((k): void => {
if (k !== 'lookupName' || extracted[k]) {
// these are safe since we are looking through the keys as set
packages/types/src/interfaces/authorship/types.ts
+1 -1
View File
@@ -2,8 +2,8 @@
/* eslint-disable */
import type { Enum, Option } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { AccountId, BlockNumber, Hash } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
/** @name UncleEntryItem */
export interface UncleEntryItem extends Enum {
packages/types/src/interfaces/babe/types.ts
+1 -1
View File
@@ -2,9 +2,9 @@
/* eslint-disable */
import type { Enum, Option, Struct, U8aFixed, Vec, u32, u64 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { AuthorityId } from '@polkadot/types/interfaces/consensus';
import type { Hash, Header } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
/** @name AllowedSlots */
export interface AllowedSlots extends Enum {
packages/types/src/interfaces/bridges/types.ts
+1 -1
View File
@@ -2,11 +2,11 @@
/* eslint-disable */
import type { BitVec, Bytes, Enum, Null, Struct, U8aFixed, Vec, bool, u32, u64 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { BlockHash } from '@polkadot/types/interfaces/chain';
import type { MultiSignature } from '@polkadot/types/interfaces/extrinsics';
import type { AuthorityList, SetId } from '@polkadot/types/interfaces/grandpa';
import type { AccountId, Balance, BlockNumber, H256, Header, MultiSigner, Weight } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
/** @name BridgedBlockHash */
export interface BridgedBlockHash extends H256 {}
packages/types/src/interfaces/collective/types.ts
+1 -1
View File
@@ -2,8 +2,8 @@
/* eslint-disable */
import type { Enum, Struct, Vec, u32 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { AccountId, BlockNumber } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
/** @name CollectiveOrigin */
export interface CollectiveOrigin extends Enum {
packages/types/src/interfaces/democracy/types.ts
+1 -1
View File
@@ -2,9 +2,9 @@
/* eslint-disable */
import type { Bytes, Enum, Option, Struct, Vec, bool, u32 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { Vote, VoteThreshold } from '@polkadot/types/interfaces/elections';
import type { AccountId, Balance, BlockNumber, Call, Hash } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
/** @name AccountVote */
export interface AccountVote extends Enum {
packages/types/src/interfaces/grandpa/types.ts
+1 -1
View File
@@ -2,12 +2,12 @@
/* eslint-disable */
import type { BTreeSet, Bytes, Enum, Option, Struct, U64, Vec, u32, u64 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { BlockHash } from '@polkadot/types/interfaces/chain';
import type { AuthorityId } from '@polkadot/types/interfaces/consensus';
import type { AuthoritySignature } from '@polkadot/types/interfaces/imOnline';
import type { BlockNumber, Hash, Header } from '@polkadot/types/interfaces/runtime';
import type { MembershipProof } from '@polkadot/types/interfaces/session';
import type { ITuple } from '@polkadot/types/types';
/** @name AuthorityIndex */
export interface AuthorityIndex extends u64 {}
packages/types/src/interfaces/identity/types.ts
+1 -1
View File
@@ -2,8 +2,8 @@
/* eslint-disable */
import type { Data, Enum, Option, Set, Struct, Vec, u32 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { AccountId, Balance, H160 } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
/** @name IdentityFields */
export interface IdentityFields extends Set {
packages/types/src/interfaces/lottery/types.ts
+1 -1
View File
@@ -2,8 +2,8 @@
/* eslint-disable */
import type { Struct, bool, u8 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { Balance, BlockNumber } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
/** @name CallIndex */
export interface CallIndex extends ITuple<[u8, u8]> {}
packages/types/src/interfaces/metadata/definitions.ts
+11 -26
View File
@@ -26,14 +26,13 @@ export default {
...v13,
...v14,
//
// will be available once v14 is the default
// TODO: Comment out all commented stuff below and remove block below
//
// ExtrinsicMetadataLatest: 'ExtrinsicMetadataV14',
// FunctionArgumentMetadataLatest: 'FunctionArgumentMetadataV13',
// FunctionMetadataLatest: 'FunctionMetadataV14',
// MetadataLatest: 'MetadataV14',
// latest mappings
ErrorMetadataLatest: 'ErrorMetadataV14',
EventMetadataLatest: 'EventMetadataV14',
ExtrinsicMetadataLatest: 'ExtrinsicMetadataV14',
FunctionArgumentMetadataLatest: 'FunctionArgumentMetadataV14',
FunctionMetadataLatest: 'FunctionMetadataV14',
MetadataLatest: 'MetadataV14',
PalletCallMetadataLatest: 'PalletCallMetadataV14',
PalletConstantMetadataLatest: 'PalletConstantMetadataV14',
PalletErrorMetadataLatest: 'PalletErrorMetadataV14',
@@ -41,24 +40,10 @@ export default {
PalletMetadataLatest: 'PalletMetadataV14',
PalletStorageMetadataLatest: 'PalletStorageMetadataV14',
SignedExtensionMetadataLatest: 'SignedExtensionMetadataV14',
// StorageEntryMetadataLatest: 'StorageEntryMetadataV14',
// StorageEntryModifierLatest: 'StorageEntryModifierV14',
// StorageEntryTypeLatest: 'StorageEntryTypeV14',
// This always maps to the latest
ErrorMetadataLatest: 'ErrorMetadataV13',
EventMetadataLatest: 'EventMetadataV13',
ExtrinsicMetadataLatest: 'ExtrinsicMetadataV13',
FunctionArgumentMetadataLatest: 'FunctionArgumentMetadataV13',
FunctionMetadataLatest: 'FunctionMetadataV13',
MetadataLatest: 'MetadataV13',
ModuleConstantMetadataLatest: 'ModuleConstantMetadataV13',
ModuleMetadataLatest: 'ModuleMetadataV13',
StorageEntryMetadataLatest: 'StorageEntryMetadataV13',
StorageEntryModifierLatest: 'StorageEntryModifierV13',
StorageEntryTypeLatest: 'StorageEntryTypeV13',
StorageMetadataLatest: 'StorageMetadataV13',
StorageHasher: 'StorageHasherV13',
StorageEntryMetadataLatest: 'StorageEntryMetadataV14',
StorageEntryModifierLatest: 'StorageEntryModifierV14',
StorageEntryTypeLatest: 'StorageEntryTypeV14',
StorageHasher: 'StorageHasherV14',
// the enum containing all the mappings
MetadataAll: {
packages/types/src/interfaces/metadata/types.ts
+10 -19
View File
@@ -5,7 +5,7 @@ import type { Bytes, Enum, GenericPortableRegistry, Option, Struct, Text, Type,
import type { SiField, SiLookupTypeId, SiType } from '@polkadot/types/interfaces/scaleInfo';
/** @name ErrorMetadataLatest */
export interface ErrorMetadataLatest extends ErrorMetadataV13 {}
export interface ErrorMetadataLatest extends ErrorMetadataV14 {}
/** @name ErrorMetadataV10 */
export interface ErrorMetadataV10 extends ErrorMetadataV9 {}
@@ -35,7 +35,7 @@ export interface ErrorMetadataV9 extends Struct {
}
/** @name EventMetadataLatest */
export interface EventMetadataLatest extends EventMetadataV13 {}
export interface EventMetadataLatest extends EventMetadataV14 {}
/** @name EventMetadataV10 */
export interface EventMetadataV10 extends EventMetadataV9 {}
@@ -66,7 +66,7 @@ export interface EventMetadataV9 extends Struct {
}
/** @name ExtrinsicMetadataLatest */
export interface ExtrinsicMetadataLatest extends ExtrinsicMetadataV13 {}
export interface ExtrinsicMetadataLatest extends ExtrinsicMetadataV14 {}
/** @name ExtrinsicMetadataV11 */
export interface ExtrinsicMetadataV11 extends Struct {
@@ -88,7 +88,7 @@ export interface ExtrinsicMetadataV14 extends Struct {
}
/** @name FunctionArgumentMetadataLatest */
export interface FunctionArgumentMetadataLatest extends FunctionArgumentMetadataV13 {}
export interface FunctionArgumentMetadataLatest extends FunctionArgumentMetadataV14 {}
/** @name FunctionArgumentMetadataV10 */
export interface FunctionArgumentMetadataV10 extends FunctionArgumentMetadataV9 {}
@@ -112,7 +112,7 @@ export interface FunctionArgumentMetadataV9 extends Struct {
}
/** @name FunctionMetadataLatest */
export interface FunctionMetadataLatest extends FunctionMetadataV13 {}
export interface FunctionMetadataLatest extends FunctionMetadataV14 {}
/** @name FunctionMetadataV10 */
export interface FunctionMetadataV10 extends FunctionMetadataV9 {}
@@ -159,7 +159,7 @@ export interface MetadataAll extends Enum {
}
/** @name MetadataLatest */
export interface MetadataLatest extends MetadataV13 {}
export interface MetadataLatest extends MetadataV14 {}
/** @name MetadataV10 */
export interface MetadataV10 extends Struct {
@@ -196,9 +196,6 @@ export interface MetadataV9 extends Struct {
readonly modules: Vec<ModuleMetadataV9>;
}
/** @name ModuleConstantMetadataLatest */
export interface ModuleConstantMetadataLatest extends ModuleConstantMetadataV13 {}
/** @name ModuleConstantMetadataV10 */
export interface ModuleConstantMetadataV10 extends ModuleConstantMetadataV9 {}
@@ -219,9 +216,6 @@ export interface ModuleConstantMetadataV9 extends Struct {
readonly docs: Vec<Text>;
}
/** @name ModuleMetadataLatest */
export interface ModuleMetadataLatest extends ModuleMetadataV13 {}
/** @name ModuleMetadataV10 */
export interface ModuleMetadataV10 extends Struct {
readonly name: Text;
@@ -352,7 +346,7 @@ export interface SignedExtensionMetadataV14 extends Struct {
}
/** @name StorageEntryMetadataLatest */
export interface StorageEntryMetadataLatest extends StorageEntryMetadataV13 {}
export interface StorageEntryMetadataLatest extends StorageEntryMetadataV14 {}
/** @name StorageEntryMetadataV10 */
export interface StorageEntryMetadataV10 extends Struct {
@@ -403,7 +397,7 @@ export interface StorageEntryMetadataV9 extends Struct {
}
/** @name StorageEntryModifierLatest */
export interface StorageEntryModifierLatest extends StorageEntryModifierV13 {}
export interface StorageEntryModifierLatest extends StorageEntryModifierV14 {}
/** @name StorageEntryModifierV10 */
export interface StorageEntryModifierV10 extends StorageEntryModifierV9 {}
@@ -428,7 +422,7 @@ export interface StorageEntryModifierV9 extends Enum {
}
/** @name StorageEntryTypeLatest */
export interface StorageEntryTypeLatest extends StorageEntryTypeV13 {}
export interface StorageEntryTypeLatest extends StorageEntryTypeV14 {}
/** @name StorageEntryTypeV10 */
export interface StorageEntryTypeV10 extends Enum {
@@ -536,7 +530,7 @@ export interface StorageEntryTypeV9 extends Enum {
}
/** @name StorageHasher */
export interface StorageHasher extends StorageHasherV13 {}
export interface StorageHasher extends StorageHasherV14 {}
/** @name StorageHasherV10 */
export interface StorageHasherV10 extends Enum {
@@ -577,9 +571,6 @@ export interface StorageHasherV9 extends Enum {
readonly isTwox64Concat: boolean;
}
/** @name StorageMetadataLatest */
export interface StorageMetadataLatest extends StorageMetadataV13 {}
/** @name StorageMetadataV10 */
export interface StorageMetadataV10 extends Struct {
readonly prefix: Text;
packages/types/src/interfaces/offences/types.ts
+1 -1
View File
@@ -2,9 +2,9 @@
/* eslint-disable */
import type { Bytes, Struct, U8aFixed, Vec } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { AccountId, Hash, Perbill } from '@polkadot/types/interfaces/runtime';
import type { IdentificationTuple, SessionIndex } from '@polkadot/types/interfaces/session';
import type { ITuple } from '@polkadot/types/types';
/** @name DeferredOffenceOf */
export interface DeferredOffenceOf extends ITuple<[Vec<OffenceDetails>, Vec<Perbill>, SessionIndex]> {}
packages/types/src/interfaces/parachains/types.ts
+1 -1
View File
@@ -2,10 +2,10 @@
/* eslint-disable */
import type { BTreeMap, BitVec, Bytes, Enum, Option, Struct, U8aFixed, Vec, bool, u32 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { Signature } from '@polkadot/types/interfaces/extrinsics';
import type { AccountId, Balance, BalanceOf, BlockNumber, H256, Hash, Header, StorageProof, ValidatorId, Weight } from '@polkadot/types/interfaces/runtime';
import type { MembershipProof, SessionIndex } from '@polkadot/types/interfaces/session';
import type { ITuple } from '@polkadot/types/types';
/** @name AbridgedCandidateReceipt */
export interface AbridgedCandidateReceipt extends Struct {
packages/types/src/interfaces/runtime/types.ts
+1 -1
View File
@@ -2,10 +2,10 @@
/* eslint-disable */
import type { Bytes, Compact, DoNotConstruct, Enum, GenericAccountId, GenericAccountIndex, GenericBlock, GenericCall, GenericConsensusEngineId, GenericEthereumAccountId, GenericLookupSource, GenericMultiAddress, Int, Null, Option, StorageKey, Struct, U8aFixed, UInt, Vec, u16, u32, u64, u8 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { AuthorityId } from '@polkadot/types/interfaces/consensus';
import type { Signature } from '@polkadot/types/interfaces/extrinsics';
import type { SystemOrigin } from '@polkadot/types/interfaces/system';
import type { ITuple } from '@polkadot/types/types';
/** @name AccountId */
export interface AccountId extends AccountId32 {}
packages/types/src/interfaces/scheduler/types.ts
+1 -1
View File
@@ -2,8 +2,8 @@
/* eslint-disable */
import type { Bytes, Option, Struct, u32, u8 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { BlockNumber, Call, PalletsOrigin } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
/** @name Period */
export interface Period extends ITuple<[BlockNumber, u32]> {}
packages/types/src/interfaces/session/types.ts
+1 -1
View File
@@ -2,9 +2,9 @@
/* eslint-disable */
import type { Bytes, Struct, U8aFixed, Vec, u32 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { AccountId, ValidatorId } from '@polkadot/types/interfaces/runtime';
import type { Exposure } from '@polkadot/types/interfaces/staking';
import type { ITuple } from '@polkadot/types/types';
/** @name BeefyKey */
export interface BeefyKey extends U8aFixed {}
packages/types/src/interfaces/society/types.ts
+1 -1
View File
@@ -2,8 +2,8 @@
/* eslint-disable */
import type { Enum, Struct, u32 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { AccountId, Balance } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
/** @name Bid */
export interface Bid extends Struct {
packages/types/src/interfaces/staking/types.ts
+1 -1
View File
@@ -2,8 +2,8 @@
/* eslint-disable */
import type { BTreeMap, Compact, Enum, Option, Struct, Vec, bool, u128, u16, u32, u64 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { AccountId, Balance, BlockNumber, Moment, PerU16, Perbill } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
/** @name ActiveEraInfo */
export interface ActiveEraInfo extends Struct {
packages/types/src/interfaces/state/types.ts
+1 -1
View File
@@ -2,8 +2,8 @@
/* eslint-disable */
import type { Bytes, Enum, HashMap, Option, StorageKey, Struct, Text, U8aFixed, Vec, bool, u32, u64 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { Hash, StorageData } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
/** @name ApiId */
export interface ApiId extends U8aFixed {}
packages/types/src/interfaces/system/types.ts
+1 -1
View File
@@ -2,9 +2,9 @@
/* eslint-disable */
import type { Bytes, Compact, Enum, GenericChainProperties, GenericEvent, HashMap, Option, Result, Struct, Text, U8aFixed, Vec, bool, i32, u32, u64, u8 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { AccountData } from '@polkadot/types/interfaces/balances';
import type { AccountId, BlockNumber, Digest, Hash, Index, Pays, Weight } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
/** @name AccountInfo */
export interface AccountInfo extends AccountInfoWithTripleRefCount {}
packages/types/src/interfaces/treasury/types.ts
+1 -1
View File
@@ -2,8 +2,8 @@
/* eslint-disable */
import type { Enum, Option, Struct, Vec, bool, u32 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { AccountId, Balance, BlockNumber, Hash } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
/** @name Bounty */
export interface Bounty extends Struct {
packages/types/src/interfaces/xcm/types.ts
+1 -1
View File
@@ -2,8 +2,8 @@
/* eslint-disable */
import type { Bytes, Compact, Enum, Null, Option, Result, Struct, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types';
import type { ITuple } from '@polkadot/types/types';
import type { AccountId, BlockNumber, Weight } from '@polkadot/types/interfaces/runtime';
import type { ITuple } from '@polkadot/types/types';
/** @name AssetInstance */
export interface AssetInstance extends AssetInstanceV1 {}
packages/types/src/lookup.ts
+4
View File
@@ -0,0 +1,4 @@
// Copyright 2017-2021 @polkadot/types authors & contributors
// SPDX-License-Identifier: Apache-2.0
export type PHANTOM_LOOKUP = 'lookup';
packages/types/src/metadata/Metadata.spec.ts
+9 -3
View File
@@ -1,14 +1,20 @@
// Copyright 2017-2021 @polkadot/types authors & contributors
// SPDX-License-Identifier: Apache-2.0
import substrateData from '@polkadot/types-support/metadata/static-substrate';
import polkadot from '@polkadot/types-support/metadata//static-polkadot';
import substrate from '@polkadot/types-support/metadata/static-substrate';
import { TypeRegistry } from '../create';
import { Metadata } from './Metadata';
const allData: Record<string, string> = {
polkadot,
substrate
};
describe('Metadata', (): void => {
it('allows creation from hex with JSON equivalence', (): void => {
const test = new Metadata(new TypeRegistry(), substrateData);
it.each(['polkadot', 'substrate'])('allows creation from hex on %s', (type): void => {
const test = new Metadata(new TypeRegistry(), allData[type]);
expect(
new Metadata(new TypeRegistry(), test.toHex()).toJSON()
packages/types/src/metadata/MetadataVersioned.ts
+14 -7
View File
@@ -1,7 +1,7 @@
// Copyright 2017-2021 @polkadot/types authors & contributors
// SPDX-License-Identifier: Apache-2.0
import type { MetadataAll, MetadataLatest, MetadataV9, MetadataV10, MetadataV11, MetadataV12, MetadataV13 } from '../interfaces/metadata';
import type { MetadataAll, MetadataLatest, MetadataV9, MetadataV10, MetadataV11, MetadataV12, MetadataV13, MetadataV14 } from '../interfaces/metadata';
import type { AnyJson, Registry } from '../types';
import { assert } from '@polkadot/util';
@@ -11,15 +11,16 @@ import { toV10 } from './v9/toV10';
import { toV11 } from './v10/toV11';
import { toV12 } from './v11/toV12';
import { toV13 } from './v12/toV13';
import { toLatest } from './v13/toLatest';
import { toV14 } from './v13/toV14';
import { toLatest } from './v14/toLatest';
import { MagicNumber } from './MagicNumber';
import { getUniqTypes, toCallsOnly } from './util';
type MetaMapped = MetadataV9 | MetadataV10 | MetadataV11 | MetadataV12 | MetadataV13;
type MetaAsX = 'asV9' | 'asV10' | 'asV11' | 'asV12' | 'asV13';
type MetaVersions = 'latest' | 9 | 10 | 11 | 12 | 13;
type MetaMapped = MetadataV9 | MetadataV10 | MetadataV11 | MetadataV12 | MetadataV13 | MetadataV14;
type MetaAsX = 'asV9' | 'asV10' | 'asV11' | 'asV12' | 'asV13' | 'asV14';
type MetaVersions = 'latest' | 9 | 10 | 11 | 12 | 13 | 14;
const LATEST_VERSION = 13;
const LATEST_VERSION = 14;
/**
* @name MetadataVersioned
@@ -113,11 +114,17 @@ export class MetadataVersioned extends Struct {
return this.#getVersion(13, toV13);
}
/**
* @description Returns the wrapped values as a V14 object
*/
public get asV14 (): MetadataV14 {
return this.#getVersion(14, toV14);
}
/**
* @description Returns the wrapped values as a latest version object
*/
public get asLatest (): MetadataLatest {
// This is non-existent & latest - applied here to do the module-specific type conversions
return this.#getVersion('latest', toLatest);
}
packages/types/src/metadata/decorate/constants/index.spec.ts
+3 -3
View File
@@ -17,14 +17,14 @@ function init (meta: string): [Constants, TypeRegistry] {
registry.setMetadata(metadata);
return [decorateConstants(registry, metadata.asLatest, 12), registry];
return [decorateConstants(registry, metadata.asLatest, metadata.version), registry];
}
describe('decorateConstants', (): void => {
it('should return constants with the correct type and value', (): void => {
const [consts, registry] = init(rpcMetadata);
const [consts] = init(rpcMetadata);
expect(consts.democracy.cooloffPeriod).toBeInstanceOf(registry.createClass('BlockNumber'));
expect((consts.democracy.cooloffPeriod as unknown as BlockNumber).bitLength()).toBe(32);
// 3 second blocks, 28 days
expect((consts.democracy.cooloffPeriod as unknown as BlockNumber).toNumber()).toEqual(28 * 24 * 60 * (60 / 3));
});
packages/types/src/metadata/decorate/constants/index.ts
+3 -5
View File
@@ -9,17 +9,15 @@ import { hexToU8a, stringCamelCase } from '@polkadot/util';
/** @internal */
// eslint-disable-next-line @typescript-eslint/no-unused-vars
export function decorateConstants (registry: Registry, { modules }: MetadataLatest, _metaVersion: number): Constants {
return modules.reduce((result: Constants, { constants, name }): Constants => {
export function decorateConstants (registry: Registry, { pallets }: MetadataLatest, _metaVersion: number): Constants {
return pallets.reduce((result: Constants, { constants, name }): Constants => {
if (constants.isEmpty) {
return result;
}
// For access, we change the index names, i.e. Democracy.EnactmentPeriod -> democracy.enactmentPeriod
result[stringCamelCase(name)] = constants.reduce((newModule: ModuleConstants, meta): ModuleConstants => {
// convert to the natural type as received
const type = meta.type.toString();
const codec = registry.createType(type as 'Raw', hexToU8a(meta.value.toHex())) as unknown;
const codec = registry.createTypeUnsafe(registry.createLookupType(meta.type), [hexToU8a(meta.value.toHex())]) as unknown;
(codec as Record<string, unknown>).meta = meta;
newModule[stringCamelCase(meta.name)] = codec as ConstantCodec;
packages/types/src/metadata/decorate/errors/index.ts
+26 -11
View File
@@ -1,20 +1,34 @@
// Copyright 2017-2021 @polkadot/types authors & contributors
// SPDX-License-Identifier: Apache-2.0
import type { DispatchErrorModule, MetadataLatest } from '../../../interfaces';
import type { DispatchErrorModule, MetadataLatest, PortableRegistry, SiField, SiVariant } from '../../../interfaces';
import type { Text, u8 } from '../../../primitive';
import type { Registry } from '../../../types';
import type { Errors, ModuleErrors } from '../types';
import { stringCamelCase } from '@polkadot/util';
function isError ({ error, index }: DispatchErrorModule, sectionIndex: number, errorIndex: number): boolean {
return index.eq(sectionIndex) && error.eq(errorIndex);
interface ItemMeta {
args: string[];
name: Text;
fields: SiField[];
index: u8;
docs: Text[];
}
export function variantToMeta (lookup: PortableRegistry, variant: SiVariant): ItemMeta {
return {
...variant,
args: variant.fields.map(({ type }) =>
lookup.getTypeDef(type).type
)
};
}
/** @internal */
export function decorateErrors (_: Registry, { modules }: MetadataLatest, metaVersion: number): Errors {
return modules.reduce((result: Errors, { errors, index, name }, _sectionIndex): Errors => {
if (!errors.length) {
export function decorateErrors (registry: Registry, { lookup, pallets }: MetadataLatest, metaVersion: number): Errors {
return pallets.reduce((result: Errors, { errors, index, name }, _sectionIndex): Errors => {
if (!errors.isSome) {
return result;
}
@@ -22,12 +36,13 @@ export function decorateErrors (_: Registry, { modules }: MetadataLatest, metaVe
? index.toNumber()
: _sectionIndex;
result[stringCamelCase(name)] = errors.reduce((newModule: ModuleErrors, meta, errorIndex): ModuleErrors => {
result[stringCamelCase(name)] = lookup.getSiType(errors.unwrap().type).def.asVariant.variants.reduce((newModule: ModuleErrors, variant): ModuleErrors => {
// we don't camelCase the error name
newModule[meta.name.toString()] = {
is: (moduleError: DispatchErrorModule): boolean =>
isError(moduleError, sectionIndex, errorIndex),
meta
newModule[variant.name.toString()] = {
is: ({ error, index }: DispatchErrorModule) =>
index.eq(sectionIndex) &&
error.eq(variant.index),
meta: registry.createType('ErrorMetadataLatest', variantToMeta(lookup, variant))
};
return newModule;
packages/types/src/metadata/decorate/events/index.ts
+8 -9
View File
@@ -7,25 +7,24 @@ import type { Events, ModuleEvents } from '../types';
import { stringCamelCase } from '@polkadot/util';
function isEvent <T extends AnyTuple> (event: IEvent<AnyTuple>, sectionIndex: number, eventIndex: number): event is IEvent<T> {
return event.index[0] === sectionIndex && event.index[1] === eventIndex;
}
import { variantToMeta } from '../errors';
/** @internal */
export function decorateEvents (_: Registry, { modules }: MetadataLatest, metaVersion: number): Events {
return modules
export function decorateEvents (registry: Registry, { lookup, pallets }: MetadataLatest, metaVersion: number): Events {
return pallets
.filter(({ events }) => events.isSome)
.reduce((result: Events, { events, index, name }, _sectionIndex): Events => {
const sectionIndex = metaVersion >= 12
? index.toNumber()
: _sectionIndex;
result[stringCamelCase(name)] = events.unwrap().reduce((newModule: ModuleEvents, meta, eventIndex): ModuleEvents => {
result[stringCamelCase(name)] = lookup.getSiType(events.unwrap().type).def.asVariant.variants.reduce((newModule: ModuleEvents, variant): ModuleEvents => {
// we don't camelCase the event name
newModule[meta.name.toString()] = {
newModule[variant.name.toString()] = {
is: <T extends AnyTuple> (eventRecord: IEvent<AnyTuple>): eventRecord is IEvent<T> =>
isEvent(eventRecord, sectionIndex, eventIndex),
meta
eventRecord.index[0] === sectionIndex &&
variant.index.eq(eventRecord.index[1]),
meta: registry.createType('EventMetadataLatest', variantToMeta(lookup, variant))
};
return newModule;
packages/types/src/metadata/decorate/extrinsics/createUnchecked.ts
+2 -2
View File
@@ -12,11 +12,11 @@ function isTx <A extends AnyTuple> (tx: IMethod<AnyTuple>, callIndex: Uint8Array
/** @internal */
export function createUnchecked (registry: Registry, section: string, callIndex: Uint8Array, callMetadata: FunctionMetadataLatest): CallFunction {
const expectedArgs = callMetadata.args;
const expectedArgs = callMetadata.fields;
const funcName = stringCamelCase(callMetadata.name);
const extrinsicFn = (...args: any[]): Call => {
assert(expectedArgs.length === args.length, () => `Extrinsic ${section}.${funcName} expects ${expectedArgs.length.valueOf()} arguments, got ${args.length}.`);
assert(expectedArgs.length === args.length, () => `Extrinsic ${section}.${funcName} expects ${expectedArgs.length} arguments, got ${args.length}.`);
return registry.createType('Call', {
args,
packages/types/src/metadata/decorate/extrinsics/index.spec.ts
+1 -1
View File
@@ -2,7 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
import { createTestPairs } from '@polkadot/keyring/testingPairs';
import metadataStatic from '@polkadot/types-support/metadata/static-substrate';
import metadataStatic from '@polkadot/types-support/metadata/v13/substrate-hex';
import { BN } from '@polkadot/util';
import { TypeRegistry } from '../../../create';
packages/types/src/metadata/decorate/extrinsics/index.ts
+16 -7
View File
@@ -10,20 +10,29 @@ import { stringCamelCase } from '@polkadot/util';
import { createUnchecked } from './createUnchecked';
/** @internal */
export function decorateExtrinsics (registry: Registry, { modules }: MetadataLatest, metaVersion: number): Extrinsics {
return modules
export function decorateExtrinsics (registry: Registry, { lookup, pallets }: MetadataLatest, metaVersion: number): Extrinsics {
return pallets
.filter(({ calls }) => calls.isSome)
.reduce((result: Extrinsics, { calls, index, name }, _sectionIndex): Extrinsics => {
const sectionName = stringCamelCase(name);
const sectionIndex = metaVersion >= 12
? index.toNumber()
: _sectionIndex;
const section = stringCamelCase(name);
result[section] = calls.unwrap().reduce((newModule: ModuleExtrinsics, callMetadata, methodIndex): ModuleExtrinsics => {
newModule[stringCamelCase(callMetadata.name)] = createUnchecked(registry, section, new Uint8Array([sectionIndex, methodIndex]), callMetadata);
result[sectionName] = lookup.getSiType(calls.unwrap().type).def.asVariant.variants
.reduce((newModule: ModuleExtrinsics, variant): ModuleExtrinsics => {
const callMetadata = registry.createType('FunctionMetadataLatest', {
...variant,
args: variant.fields.map(({ name, type }, index) => ({
name: stringCamelCase(name.unwrapOr(`param${index}`)),
type: lookup.getTypeDef(type).type
}))
});
return newModule;
}, {});
newModule[stringCamelCase(callMetadata.name)] = createUnchecked(registry, sectionName, new Uint8Array([sectionIndex, callMetadata.index.toNumber()]), callMetadata);
return newModule;
}, {});
return result;
}, {});
packages/types/src/metadata/decorate/index.spec.ts
+2 -1
View File
@@ -5,6 +5,7 @@ import json from '@polkadot/types-support/metadata/static-substrate';
import { u8aToHex } from '@polkadot/util';
import { TypeRegistry } from '../../create';
import { u32 } from '../../primitive';
import { Metadata } from '../Metadata';
import { decorateConstants, decorateExtrinsics, decorateStorage } from './';
@@ -48,7 +49,7 @@ describe('Decorated', () => {
it('should return constants with the correct type and value', (): void => {
const consts = decorateConstants(registry, metadata.asLatest, metadata.version);
expect(consts.democracy.cooloffPeriod).toBeInstanceOf(registry.createClass('BlockNumber'));
expect(consts.democracy.cooloffPeriod).toBeInstanceOf(u32); // BlockNumber
expect(consts.democracy.cooloffPeriod.toHex()).toEqual('0x000c4e00');
});
});

Some files were not shown because too many files have changed in this diff Show More