From 48f91ae0da709de43eeae6e14f7fe0ae153db4b1 Mon Sep 17 00:00:00 2001 From: Jaco Date: Mon, 26 Jul 2021 10:33:15 +0300 Subject: [PATCH] Adjust PortableRegistry (#3811) * Adjust PortableRegistry * Adjust formatting * Additional formatting picks * Readability * Replacement comment --- packages/api-contract/src/MetaRegistry.ts | 1 + packages/typegen/src/generate/consts.ts | 22 ++- packages/typegen/src/generate/errors.ts | 14 +- packages/typegen/src/generate/events.ts | 22 ++- .../typegen/src/generate/interfaceRegistry.ts | 14 +- packages/typegen/src/generate/query.ts | 22 ++- packages/typegen/src/generate/rpc.ts | 14 +- packages/typegen/src/generate/tx.ts | 22 ++- packages/typegen/src/util/derived.ts | 9 +- packages/typegen/src/util/formatting.ts | 106 ++++++++------ packages/typegen/src/util/imports.ts | 4 +- packages/types/src/augment/registry.ts | 19 ++- packages/types/src/codec/DoNotConstruct.ts | 2 +- packages/types/src/create/encodeTypes.ts | 15 +- packages/types/src/create/types.ts | 1 + .../types/src/generic/PortableRegistry.ts | 138 ++++++++++++------ .../src/interfaces/extrinsics/definitions.ts | 1 + .../types/src/interfaces/extrinsics/types.ts | 3 + .../types/src/interfaces/metadata/types.ts | 118 +++++++++++++-- packages/types/src/interfaces/metadata/v14.ts | 17 +++ .../src/interfaces/scaleInfo/definitions.ts | 14 +- 21 files changed, 381 insertions(+), 197 deletions(-) diff --git a/packages/api-contract/src/MetaRegistry.ts b/packages/api-contract/src/MetaRegistry.ts index 4a1e0829b5..9f71deb303 100644 --- a/packages/api-contract/src/MetaRegistry.ts +++ b/packages/api-contract/src/MetaRegistry.ts @@ -24,6 +24,7 @@ const PRIMITIVE_ALIAS: Record = { const PRIMITIVE_ALWAYS = ['AccountId', 'AccountIndex', 'Address', 'Balance']; +// TODO Replace usages with PortableRegistry export class MetaRegistry extends TypeRegistry { public readonly metaTypeDefs: TypeDef[] = []; diff --git a/packages/typegen/src/generate/consts.ts b/packages/typegen/src/generate/consts.ts index 889bf52c7c..d25e7affee 100644 --- a/packages/typegen/src/generate/consts.ts +++ b/packages/typegen/src/generate/consts.ts @@ -51,23 +51,21 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, }) .sort(compareName); - const types = [ - ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({ - file: packagePath, - types: Object.keys(imports.localTypes[packagePath]) - })), - { - file: '@polkadot/api/types', - types: ['ApiTypes'] - } - ]; - return generateForMetaTemplate({ headerType: 'chain', imports, isStrict, modules, - types + types: [ + ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({ + file: packagePath, + types: Object.keys(imports.localTypes[packagePath]) + })), + { + file: '@polkadot/api/types', + types: ['ApiTypes'] + } + ] }); }); } diff --git a/packages/typegen/src/generate/errors.ts b/packages/typegen/src/generate/errors.ts index 292bcc1e28..c38c143ca3 100644 --- a/packages/typegen/src/generate/errors.ts +++ b/packages/typegen/src/generate/errors.ts @@ -31,19 +31,17 @@ function generateForMeta (meta: Metadata, dest: string, isStrict: boolean): void })) .sort(compareName); - const types = [ - { - file: '@polkadot/api/types', - types: ['ApiTypes'] - } - ]; - return generateForMetaTemplate({ headerType: 'chain', imports, isStrict, modules, - types + types: [ + { + file: '@polkadot/api/types', + types: ['ApiTypes'] + } + ] }); }); } diff --git a/packages/typegen/src/generate/events.ts b/packages/typegen/src/generate/events.ts index e121ce0420..98a921c803 100644 --- a/packages/typegen/src/generate/events.ts +++ b/packages/typegen/src/generate/events.ts @@ -44,23 +44,21 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, })) .sort(compareName); - const types = [ - ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({ - file: packagePath, - types: Object.keys(imports.localTypes[packagePath]) - })), - { - file: '@polkadot/api/types', - types: ['ApiTypes'] - } - ]; - return generateForMetaTemplate({ headerType: 'chain', imports, isStrict, modules, - types + types: [ + ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({ + file: packagePath, + types: Object.keys(imports.localTypes[packagePath]) + })), + { + file: '@polkadot/api/types', + types: ['ApiTypes'] + } + ] }); }); } diff --git a/packages/typegen/src/generate/interfaceRegistry.ts b/packages/typegen/src/generate/interfaceRegistry.ts index 51eb939c5a..8fea51c8fe 100644 --- a/packages/typegen/src/generate/interfaceRegistry.ts +++ b/packages/typegen/src/generate/interfaceRegistry.ts @@ -62,18 +62,16 @@ export function generateInterfaceTypes (importDefinitions: { [importPath: string }); }); - const types = [ - ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({ - file: packagePath, - types: Object.keys(imports.localTypes[packagePath]) - })) - ]; - return generateInterfaceTypesTemplate({ headerType: 'defs', imports, items: items.sort((a, b) => a.localeCompare(b)), - types + types: [ + ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({ + file: packagePath, + types: Object.keys(imports.localTypes[packagePath]) + })) + ] }); }); } diff --git a/packages/typegen/src/generate/query.ts b/packages/typegen/src/generate/query.ts index f40c580417..24e21f6331 100644 --- a/packages/typegen/src/generate/query.ts +++ b/packages/typegen/src/generate/query.ts @@ -127,23 +127,21 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr imports.typesTypes.Observable = true; - const types = [ - ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({ - file: packagePath, - types: Object.keys(imports.localTypes[packagePath]) - })), - { - file: '@polkadot/api/types', - types: ['ApiTypes'] - } - ]; - return generateForMetaTemplate({ headerType: 'chain', imports, isStrict, modules, - types + types: [ + ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({ + file: packagePath, + types: Object.keys(imports.localTypes[packagePath]) + })), + { + file: '@polkadot/api/types', + types: ['ApiTypes'] + } + ] }); }); } diff --git a/packages/typegen/src/generate/rpc.ts b/packages/typegen/src/generate/rpc.ts index 5213bbef66..5e229ac084 100644 --- a/packages/typegen/src/generate/rpc.ts +++ b/packages/typegen/src/generate/rpc.ts @@ -126,18 +126,16 @@ export function generateRpcTypes (registry: TypeRegistry, importDefinitions: Rec imports.typesTypes.Observable = true; - const types = [ - ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({ - file: packagePath, - types: Object.keys(imports.localTypes[packagePath]) - })) - ]; - return generateRpcTypesTemplate({ headerType: 'chain', imports, modules, - types + types: [ + ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({ + file: packagePath, + types: Object.keys(imports.localTypes[packagePath]) + })) + ] }); }); } diff --git a/packages/typegen/src/generate/tx.ts b/packages/typegen/src/generate/tx.ts index 938a61b83b..1025f78040 100644 --- a/packages/typegen/src/generate/tx.ts +++ b/packages/typegen/src/generate/tx.ts @@ -70,23 +70,21 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr }) .sort(compareName); - const types = [ - ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({ - file: packagePath, - types: Object.keys(imports.localTypes[packagePath]) - })), - { - file: '@polkadot/api/types', - types: ['ApiTypes', 'SubmittableExtrinsic'] - } - ]; - return generateForMetaTemplate({ headerType: 'chain', imports, isStrict, modules, - types + types: [ + ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({ + file: packagePath, + types: Object.keys(imports.localTypes[packagePath]) + })), + { + file: '@polkadot/api/types', + types: ['ApiTypes', 'SubmittableExtrinsic'] + } + ] }); }); } diff --git a/packages/typegen/src/util/derived.ts b/packages/typegen/src/util/derived.ts index 5d24001644..375e2c32af 100644 --- a/packages/typegen/src/util/derived.ts +++ b/packages/typegen/src/util/derived.ts @@ -10,7 +10,7 @@ import { ClassOfUnsafe, getTypeDef } from '@polkadot/types/create'; import { TypeDefInfo } from '@polkadot/types/create/types'; import { GenericAccountId, GenericLookupSource, GenericVote } from '@polkadot/types/generic'; import { AllConvictions } from '@polkadot/types/interfaces/democracy/definitions'; -import { Null } from '@polkadot/types/primitive'; +import { bool, Null } from '@polkadot/types/primitive'; import * as primitiveClasses from '@polkadot/types/primitive'; import { isChildClass, stringify } from '@polkadot/util'; @@ -28,7 +28,10 @@ const voteConvictions = arrayToStrType(AllConvictions); /** @internal */ export function getDerivedTypes (registry: Registry, definitions: Record, type: string, primitiveName: string, imports: TypeImports): string[] { // `primitiveName` represents the actual primitive type our type is mapped to - const isCompact = isCompactEncodable((primitiveClasses as Record)[primitiveName] || ClassOfUnsafe(registry, type)); + const isCompact = isCompactEncodable( + (primitiveClasses as Record)[primitiveName] || + ClassOfUnsafe(registry, type) + ); const def = getTypeDef(type); setImports(definitions, imports, ['Option', 'Vec', isCompact ? 'Compact' : '']); @@ -121,7 +124,7 @@ export function getSimilarTypes (registry: Registry, definitions: Record, imports: TypeImports) => string> = { - [TypeDefInfo.Compact]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { +const formatters: Record, imports: TypeImports, withShortcut: boolean) => string> = { + [TypeDefInfo.Compact]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { setImports(definitions, imports, ['Compact']); - return paramsNotation('Compact', formatType(registry, definitions, (typeDef.sub as TypeDef).type, imports)); + const sub = typeDef.sub as TypeDef; + + return paramsNotation('Compact', formatType(registry, definitions, sub.lookupName || sub.type, imports, withShortcut)); }, - [TypeDefInfo.DoNotConstruct]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { + [TypeDefInfo.DoNotConstruct]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { setImports(definitions, imports, ['DoNotConstruct']); return 'DoNotConstruct'; }, - [TypeDefInfo.Enum]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { + [TypeDefInfo.Enum]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { + if (typeDef.lookupName) { + return typeDef.lookupName; + } + throw new Error(`TypeDefInfo.Enum: Not implemented on ${stringify(typeDef)}`); }, - [TypeDefInfo.Int]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { + [TypeDefInfo.Int]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { throw new Error(`TypeDefInfo.Int: Not implemented on ${stringify(typeDef)}`); }, - [TypeDefInfo.UInt]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { + [TypeDefInfo.UInt]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { throw new Error(`TypeDefInfo.UInt: Not implemented on ${stringify(typeDef)}`); }, - [TypeDefInfo.Null]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { + [TypeDefInfo.Null]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { setImports(definitions, imports, ['Null']); return 'Null'; }, - [TypeDefInfo.Option]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { + [TypeDefInfo.Option]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { setImports(definitions, imports, ['Option']); - return paramsNotation('Option', formatType(registry, definitions, (typeDef.sub as TypeDef).type, imports)); + const sub = (typeDef.sub as TypeDef); + + return paramsNotation('Option', formatType(registry, definitions, sub.lookupName || sub.type, imports, withShortcut)); }, - [TypeDefInfo.Plain]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { + [TypeDefInfo.Plain]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { + setImports(definitions, imports, [typeDef.type]); + return typeDef.type; }, - [TypeDefInfo.Set]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { + [TypeDefInfo.Set]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { throw new Error(`TypeDefInfo.Set: Not implemented on ${stringify(typeDef)}`); }, - [TypeDefInfo.Si]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { - throw new Error(`TypeDefInfo.Si: Not implemented on ${stringify(typeDef)}`); + [TypeDefInfo.Si]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { + return formatType(registry, definitions, registry.lookup.getTypeDef(typeDef.type), imports, withShortcut); }, - [TypeDefInfo.Struct]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { + [TypeDefInfo.Struct]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { setImports(definitions, imports, ['Struct']); - return `{ ${ - ((typeDef.sub as TypeDef[]).map(({ name, type }, index) => [ + return `{${withShortcut ? ' ' : '\n'}${ + ((typeDef.sub as TypeDef[]).map(({ lookupName, name, type }, index) => [ name || `unknown${index}`, - formatType(registry, definitions, type, imports) - ])).map(([k, t]) => `${k}: ${t};`).join(' ') - } } & Struct`; + formatType(registry, definitions, lookupName || type, imports, withShortcut) + ])).map(([k, t]) => `${withShortcut ? '' : ' readonly '}${k}: ${t};`).join(withShortcut ? ' ' : '\n') + }${withShortcut ? ' ' : '\n '}} & Struct`; }, - [TypeDefInfo.Tuple]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { + [TypeDefInfo.Tuple]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { setImports(definitions, imports, ['ITuple']); // `(a,b)` gets transformed into `ITuple<[a, b]>` return paramsNotation('ITuple', `[${ - ((typeDef.sub as TypeDef[]).map(({ type }) => - formatType(registry, definitions, type, imports)) - ).join(', ') + ((typeDef.sub as TypeDef[]).map(({ lookupName, type }) => + formatType(registry, definitions, lookupName || type, imports, withShortcut) + )).join(', ') }]`); }, - [TypeDefInfo.Vec]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { + [TypeDefInfo.Vec]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { setImports(definitions, imports, ['Vec']); - return paramsNotation('Vec', formatType(registry, definitions, (typeDef.sub as TypeDef).type, imports)); - }, - [TypeDefInfo.VecFixed]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { - const type = (typeDef.sub as TypeDef).type; + const sub = (typeDef.sub as TypeDef); - if (type === 'u8') { + return paramsNotation('Vec', formatType(registry, definitions, sub.lookupName || sub.type, imports, withShortcut)); + }, + [TypeDefInfo.VecFixed]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { + const sub = (typeDef.sub as TypeDef); + + if (sub.type === 'u8') { setImports(definitions, imports, ['U8aFixed']); return 'U8aFixed'; @@ -161,42 +173,42 @@ const formatters: Record, imports: TypeImports) => { + [TypeDefInfo.BTreeMap]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { setImports(definitions, imports, ['BTreeMap']); const [keyDef, valDef] = (typeDef.sub as TypeDef[]); - return `BTreeMap<${formatType(registry, definitions, keyDef.type, imports)}, ${formatType(registry, definitions, valDef.type, imports)}>`; + return `BTreeMap<${formatType(registry, definitions, keyDef.lookupName || keyDef.type, imports, withShortcut)}, ${formatType(registry, definitions, valDef.lookupName || valDef.type, imports, withShortcut)}>`; }, - [TypeDefInfo.BTreeSet]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { + [TypeDefInfo.BTreeSet]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { setImports(definitions, imports, ['BTreeSet']); const valDef = typeDef.sub as TypeDef; - return `BTreeSet<${formatType(registry, definitions, valDef.type, imports)}>`; + return `BTreeSet<${formatType(registry, definitions, valDef.lookupName || valDef.type, imports, withShortcut)}>`; }, - [TypeDefInfo.HashMap]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { + [TypeDefInfo.HashMap]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { setImports(definitions, imports, ['HashMap']); const [keyDef, valDef] = (typeDef.sub as TypeDef[]); - return `HashMap<${formatType(registry, definitions, keyDef.type, imports)}, ${formatType(registry, definitions, valDef.type, imports)}>`; + return `HashMap<${formatType(registry, definitions, keyDef.lookupName || keyDef.type, imports, withShortcut)}, ${formatType(registry, definitions, valDef.lookupName || valDef.type, imports, withShortcut)}>`; }, - [TypeDefInfo.Linkage]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { - const type = (typeDef.sub as TypeDef).type; - + [TypeDefInfo.Linkage]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { setImports(definitions, imports, ['Linkage']); - return paramsNotation('Linkage', formatType(registry, definitions, type, imports)); + const sub = (typeDef.sub as TypeDef); + + return paramsNotation('Linkage', formatType(registry, definitions, sub.lookupName || sub.type, imports, withShortcut)); }, - [TypeDefInfo.Result]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports) => { + [TypeDefInfo.Result]: (registry: Registry, typeDef: TypeDef, definitions: Record, imports: TypeImports, withShortcut: boolean) => { setImports(definitions, imports, ['Result']); - const [okDef, errorDef] = (typeDef.sub as TypeDef[]); + const [okDef, errDef] = (typeDef.sub as TypeDef[]); - return `Result<${formatType(registry, definitions, okDef.type, imports)}, ${formatType(registry, definitions, errorDef.type, imports)}>`; + return `Result<${formatType(registry, definitions, okDef.lookupName || okDef.type, imports, withShortcut)}, ${formatType(registry, definitions, errDef.lookupName || errDef.type, imports, withShortcut)}>`; } }; @@ -205,7 +217,7 @@ const formatters: Record, type: string | String | TypeDef, imports: TypeImports): string { +export function formatType (registry: Registry, definitions: Record, type: string | String | TypeDef, imports: TypeImports, withShortcut = false): string { let typeDef: TypeDef; if (isString(type)) { @@ -213,7 +225,7 @@ export function formatType (registry: Registry, definitions: Record, imports: TypeI // TypeDef.sub is a `TypeDef | TypeDef[]` if (Array.isArray(typeDef.sub)) { - typeDef.sub.forEach((subType) => setImports(allDefs, imports, [subType.type])); + typeDef.sub.forEach((subType) => setImports(allDefs, imports, [subType.lookupName || subType.type])); } else if (typeDef.sub && (typeDef.info !== TypeDefInfo.VecFixed || typeDef.sub.type !== 'u8')) { // typeDef.sub is a TypeDef in this case - setImports(allDefs, imports, [typeDef.sub.type]); + setImports(allDefs, imports, [typeDef.sub.lookupName || typeDef.sub.type]); } } else if (type.includes('[') && type.includes('|')) { // We split the types (we already dod the check above, so safe-path should not be caught) diff --git a/packages/types/src/augment/registry.ts b/packages/types/src/augment/registry.ts index 1eacaa5e1b..ec2bc89f6c 100644 --- a/packages/types/src/augment/registry.ts +++ b/packages/types/src/augment/registry.ts @@ -25,14 +25,14 @@ import type { ApprovalFlag, DefunctVoter, Renouncing, SetIndex, Vote, VoteIndex, import type { CreatedBlock, ImportedAux } from '@polkadot/types/interfaces/engine'; import type { EthAccount, EthBlock, EthBloom, EthCallRequest, EthFilter, EthFilterAddress, EthFilterChanges, EthFilterTopic, EthFilterTopicEntry, EthFilterTopicInner, EthHeader, EthLog, EthReceipt, EthRichBlock, EthRichHeader, EthStorageProof, EthSubKind, EthSubParams, EthSubResult, EthSyncInfo, EthSyncStatus, EthTransaction, EthTransactionAction, EthTransactionCondition, EthTransactionRequest, EthTransactionSignature, EthTransactionStatus, EthWork, EthereumAccountId, EthereumLookupSource, EthereumSignature } from '@polkadot/types/interfaces/eth'; import type { EvmAccount, EvmLog, EvmVicinity, ExitError, ExitFatal, ExitReason, ExitRevert, ExitSucceed } from '@polkadot/types/interfaces/evm'; -import type { AnySignature, EcdsaSignature, Ed25519Signature, Extrinsic, ExtrinsicEra, ExtrinsicPayload, ExtrinsicPayloadUnknown, ExtrinsicPayloadV4, ExtrinsicSignature, ExtrinsicSignatureV4, ExtrinsicUnknown, ExtrinsicV4, ImmortalEra, MortalEra, MultiSignature, Signature, SignerPayload, Sr25519Signature } from '@polkadot/types/interfaces/extrinsics'; +import type { AnySignature, EcdsaSignature, Ed25519Signature, Era, Extrinsic, ExtrinsicEra, ExtrinsicPayload, ExtrinsicPayloadUnknown, ExtrinsicPayloadV4, ExtrinsicSignature, ExtrinsicSignatureV4, ExtrinsicUnknown, ExtrinsicV4, ImmortalEra, MortalEra, MultiSignature, Signature, SignerPayload, Sr25519Signature } from '@polkadot/types/interfaces/extrinsics'; import type { AssetOptions, Owner, PermissionLatest, PermissionVersions, PermissionsV1 } from '@polkadot/types/interfaces/genericAsset'; import type { ActiveGilt, ActiveGiltsTotal, ActiveIndex, GiltBid } from '@polkadot/types/interfaces/gilt'; import type { AuthorityIndex, AuthorityList, AuthoritySet, AuthoritySetChange, AuthoritySetChanges, AuthorityWeight, DelayKind, DelayKindBest, EncodedFinalityProofs, ForkTreePendingChange, ForkTreePendingChangeNode, GrandpaCommit, GrandpaEquivocation, GrandpaEquivocationProof, GrandpaEquivocationValue, GrandpaJustification, GrandpaPrecommit, GrandpaPrevote, GrandpaSignedPrecommit, JustificationNotification, KeyOwnerProof, NextAuthority, PendingChange, PendingPause, PendingResume, Precommits, Prevotes, ReportedRoundStates, RoundState, SetId, StoredPendingChange, StoredState } from '@polkadot/types/interfaces/grandpa'; import type { IdentityFields, IdentityInfo, IdentityInfoAdditional, IdentityJudgement, RegistrarIndex, RegistrarInfo, Registration, RegistrationJudgement } 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, ErrorMetadataV9, EventMetadataLatest, EventMetadataV10, EventMetadataV11, EventMetadataV12, EventMetadataV13, EventMetadataV9, ExtrinsicMetadataLatest, ExtrinsicMetadataV11, ExtrinsicMetadataV12, ExtrinsicMetadataV13, ExtrinsicMetadataV14, FunctionArgumentMetadataLatest, FunctionArgumentMetadataV10, FunctionArgumentMetadataV11, FunctionArgumentMetadataV12, FunctionArgumentMetadataV13, FunctionArgumentMetadataV9, FunctionMetadataLatest, FunctionMetadataV10, FunctionMetadataV11, FunctionMetadataV12, FunctionMetadataV13, 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, 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 { 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'; @@ -386,6 +386,7 @@ declare module '@polkadot/types/types/registry' { 'Option': Option; 'Option': Option; 'Option': Option; + 'Option': Option; 'Option': Option; 'Option': Option; 'Option': Option; @@ -395,6 +396,7 @@ declare module '@polkadot/types/types/registry' { 'Option': Option; 'Option': Option; 'Option': Option; + 'Option': Option; 'Option': Option; 'Option': Option; 'Option': Option; @@ -436,6 +438,7 @@ declare module '@polkadot/types/types/registry' { 'Option': Option; 'Option': Option; 'Option': Option; + 'Option': Option; 'Option': Option; 'Option': Option; 'Option': Option; @@ -483,12 +486,14 @@ declare module '@polkadot/types/types/registry' { 'Option': Option; 'Option': Option; 'Option': Option; + 'Option': Option; 'Option': Option; 'Option': Option; 'Option': Option; 'Option': Option; 'Option': Option; 'Option': Option; + 'Option': Option; 'Option': Option; 'Option': Option; 'Option': Option; @@ -1299,6 +1304,7 @@ declare module '@polkadot/types/types/registry' { 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; + 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; @@ -1308,6 +1314,7 @@ declare module '@polkadot/types/types/registry' { 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; + 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; @@ -1349,6 +1356,7 @@ declare module '@polkadot/types/types/registry' { 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; + 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; @@ -1396,12 +1404,14 @@ declare module '@polkadot/types/types/registry' { 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; + 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; + 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; 'Vec': Vec; @@ -2212,6 +2222,7 @@ declare module '@polkadot/types/types/registry' { EncodedFinalityProofs: EncodedFinalityProofs; EncodedJustification: EncodedJustification; EpochAuthorship: EpochAuthorship; + Era: Era; EraIndex: EraIndex; EraPoints: EraPoints; EraRewardPoints: EraRewardPoints; @@ -2221,6 +2232,7 @@ declare module '@polkadot/types/types/registry' { ErrorMetadataV11: ErrorMetadataV11; ErrorMetadataV12: ErrorMetadataV12; ErrorMetadataV13: ErrorMetadataV13; + ErrorMetadataV14: ErrorMetadataV14; ErrorMetadataV9: ErrorMetadataV9; EthAccount: EthAccount; EthBlock: EthBlock; @@ -2262,6 +2274,7 @@ declare module '@polkadot/types/types/registry' { EventMetadataV11: EventMetadataV11; EventMetadataV12: EventMetadataV12; EventMetadataV13: EventMetadataV13; + EventMetadataV14: EventMetadataV14; EventMetadataV9: EventMetadataV9; EventRecord: EventRecord; EvmAccount: EvmAccount; @@ -2309,12 +2322,14 @@ declare module '@polkadot/types/types/registry' { FunctionArgumentMetadataV11: FunctionArgumentMetadataV11; FunctionArgumentMetadataV12: FunctionArgumentMetadataV12; FunctionArgumentMetadataV13: FunctionArgumentMetadataV13; + FunctionArgumentMetadataV14: FunctionArgumentMetadataV14; FunctionArgumentMetadataV9: FunctionArgumentMetadataV9; FunctionMetadataLatest: FunctionMetadataLatest; FunctionMetadataV10: FunctionMetadataV10; FunctionMetadataV11: FunctionMetadataV11; FunctionMetadataV12: FunctionMetadataV12; FunctionMetadataV13: FunctionMetadataV13; + FunctionMetadataV14: FunctionMetadataV14; FunctionMetadataV9: FunctionMetadataV9; FundIndex: FundIndex; FundInfo: FundInfo; diff --git a/packages/types/src/codec/DoNotConstruct.ts b/packages/types/src/codec/DoNotConstruct.ts index 6de6249d79..ac0300b204 100644 --- a/packages/types/src/codec/DoNotConstruct.ts +++ b/packages/types/src/codec/DoNotConstruct.ts @@ -18,7 +18,7 @@ export class DoNotConstruct implements Codec { constructor (registry: Registry, typeName = 'DoNotConstruct') { this.registry = registry; - this.#neverError = new Error(`Cannot construct unknown type ${typeName}`); + this.#neverError = new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`); throw this.#neverError; } diff --git a/packages/types/src/create/encodeTypes.ts b/packages/types/src/create/encodeTypes.ts index 6f9cf9446b..41cf4eeaaa 100644 --- a/packages/types/src/create/encodeTypes.ts +++ b/packages/types/src/create/encodeTypes.ts @@ -78,7 +78,7 @@ function encodeStruct (registry: Registry, typeDef: TypeDef): string { return encodeSubTypes(registry, typeDef.sub, false, { ...( typeDef.alias - ? { alias: [...typeDef.alias.entries()].reduce>((all, [k, v]) => ({ + ? { _alias: [...typeDef.alias.entries()].reduce>((all, [k, v]) => ({ ...all, [k]: v }), {}) } @@ -153,12 +153,14 @@ const encoders: Record st encodeVecFixed(registry, typeDef) }; -function encodeType (registry: Registry, typeDef: TypeDef): string { +function encodeType (registry: Registry, typeDef: TypeDef, withLookup = true): string { const encoder = encoders[typeDef.info]; assert(encoder, () => `Cannot encode type ${stringify(typeDef)}`); - return typeDef.lookupName || encoder(registry, typeDef); + return withLookup && typeDef.lookupName + ? typeDef.lookupName + : encoder(registry, typeDef); } export function encodeTypeDef (registry: Registry, typeDef: TypeDef): string { @@ -175,13 +177,8 @@ export function encodeTypeDef (registry: Registry, typeDef: TypeDef): string { } export function withTypeString (registry: Registry, typeDef: Omit): TypeDef { - const partial = { ...typeDef } as TypeDef; - - // for the outer-most type, we ignore the lookupName - delete partial.lookupName; - return { ...typeDef, - type: encodeType(registry, partial) + type: encodeType(registry, typeDef as TypeDef, false) }; } diff --git a/packages/types/src/create/types.ts b/packages/types/src/create/types.ts index 9778708535..87a2e63915 100644 --- a/packages/types/src/create/types.ts +++ b/packages/types/src/create/types.ts @@ -42,6 +42,7 @@ export interface TypeDef { length?: number; lookupIndex?: number; lookupName?: string; + lookupNameRoot?: string; name?: string; namespace?: string; sub?: TypeDef | TypeDef[]; diff --git a/packages/types/src/generic/PortableRegistry.ts b/packages/types/src/generic/PortableRegistry.ts index fe9b3561e6..7ce6a752b3 100644 --- a/packages/types/src/generic/PortableRegistry.ts +++ b/packages/types/src/generic/PortableRegistry.ts @@ -3,7 +3,7 @@ import type { Vec } from '../codec/Vec'; import type { PortableType } from '../interfaces/metadata'; -import type { SiField, SiLookupTypeId, SiType, SiTypeDefArray, SiTypeDefCompact, SiTypeDefComposite, SiTypeDefSequence, SiTypeDefTuple, SiTypeDefVariant, SiVariant } from '../interfaces/scaleInfo'; +import type { SiField, SiLookupTypeId, SiPath, SiType, SiTypeDefArray, SiTypeDefCompact, SiTypeDefComposite, SiTypeDefSequence, SiTypeDefTuple, SiTypeDefVariant, SiVariant } from '../interfaces/scaleInfo'; import type { Type } from '../primitive/Type'; import type { Registry, TypeDef } from '../types'; @@ -25,14 +25,16 @@ const PRIMITIVE_INK = ['AccountId', 'AccountIndex', 'Address', 'Balance']; // These are types where we have a specific decoding/encoding override + helpers const PRIMITIVE_SP = [ + 'node_runtime::Call', + 'node_runtime::Event', + 'sp_arithmetic::per_things::*', 'sp_core::crypto::AccountId32', 'sp_runtime::generic::era::Era', 'sp_runtime::multiaddress::MultiAddress', 'pallet_democracy::vote::Vote', 'pallet_identity::types::Data', - 'primitive_types::H160', - 'primitive_types::H256', - 'primitive_types::H512' + 'pallet_identity::types::IdentityFields', + 'primitive_types::*' ]; // These we never use these as top-level names, they are wrappers @@ -41,33 +43,84 @@ const WRAPPERS = ['Box', 'BTreeMap', 'Cow', 'Result', 'Option']; // These are reserved and conflicts with built-in Codec definitions const RESERVED = ['entries', 'hash', 'keys', 'size']; +// check if the path matches the PRIMITIVE_SP (with wildcards) +function isPrimitivePath (path: SiPath): boolean { + return !!path.length && ( + ( + path.length > 2 && + path[0].eq('ink_env') && + path[1].eq('types') + ) || + PRIMITIVE_INK.includes(path[path.length - 1].toString()) || + PRIMITIVE_SP + .map((p) => p.split('::')) + .some((parts) => + path.length === parts.length && + parts.every((p, index) => + p === '*' || + path[index].eq(p) + ) + ) + ); +} + function removeDuplicateNames (names: (string | null)[]): (string | null)[] { return names.map((name, index): string | null => - !name || names.some((o, i) => index !== i && name === o) + !name || WRAPPERS.includes(name) || names.some((o, i) => index !== i && name === o) ? null : name ); } +function extractName (types: PortableType[], { def, params, path }: SiType): string | null { + if (def.isCompact) { + // Do magic for compact naming + const instanceType = types[def.asCompact.type.toNumber()]; + + if (instanceType.type.def.isPrimitive) { + return `Compact${instanceType.type.def.asPrimitive.toString()}`; + } + } + + if (!path.length) { + return null; + } + + const parts = path.map((p) => stringUpperFirst(stringCamelCase(p))); + + // sp_runtime::generic::digest::Digest -> sp_runtime::generic::Digest + // sp_runtime::multiaddress::MultiAddress -> sp_runtime::MultiAddress + if (parts.length >= 2 && parts[parts.length - 1].toLowerCase() === parts[parts.length - 2].toLowerCase()) { + parts[parts.length - 2] = parts[parts.length - 1]; + parts.pop(); + } + + let typeName = parts.join(''); + + if (parts.length === 2 && parts[parts.length - 1] === 'RawOrigin' && params.length === 2 && params[1].type.isSome) { + // Do magic for RawOrigin lookup + const instanceType = types[params[1].type.unwrap().toNumber()]; + + if (instanceType.type.path.length === 2) { + typeName = `${typeName}${instanceType.type.path[1].toString()}`; + } + } else if (params.length === 1 && params[0].type.isSome) { + // Do magic for single params primitive lookup + const instanceType = types[params[0].type.unwrap().toNumber()]; + + if (instanceType.type.def.isPrimitive) { + typeName = `${typeName}${instanceType.type.def.asPrimitive.toString()}`; + } + } + + return typeName; +} + function extractNames (types: PortableType[]): Record { return removeDuplicateNames( - types.map(({ type: { path } }): string | null => { - if (!path.length) { - return null; - } - - const parts = path.map((p) => stringUpperFirst(stringCamelCase(p))); - - if (parts.length >= 2 && parts[parts.length - 1] === parts[parts.length - 2]) { - parts.pop(); - } - - const typeName = parts.join(''); - - return WRAPPERS.includes(typeName) || ['frame_support'].includes(path[0].toString()) - ? null - : typeName; - }) + types.map(({ type }) => + extractName(types, type) + ) ).reduce>((all, name, index) => { if (name) { all[index] = name; @@ -124,10 +177,18 @@ export class GenericPortableRegistry extends Struct { const extracted = this.#extract(this.getSiType(lookupId), lookupIndex); - Object.keys(extracted).forEach((key): void => { - // these are safe since we are looking through the keys as set - this.#typeDefs[lookupIndex][key as 'info'] = extracted[key as 'info']; + Object.keys(extracted).forEach((k): void => { + if (k !== 'lookupName' || extracted[k]) { + // these are safe since we are looking through the keys as set + this.#typeDefs[lookupIndex][k as 'info'] = extracted[k as 'info']; + } }); + + // don't set lookupName on lower-level, we want to always direct to the type + if (extracted.info === TypeDefInfo.Plain) { + this.#typeDefs[lookupIndex].lookupNameRoot = this.#typeDefs[lookupIndex].lookupName; + delete this.#typeDefs[lookupIndex].lookupName; + } } return this.#typeDefs[lookupIndex]; @@ -138,7 +199,7 @@ export class GenericPortableRegistry extends Struct { const lookupIndex = lookupId.toNumber(); // Setup for a lookup on complex types - return [TypeDefInfo.Enum, TypeDefInfo.Struct].includes(typeDef.info) + return [TypeDefInfo.Enum, TypeDefInfo.Struct].includes(typeDef.info) && typeDef.lookupName ? { docs: typeDef.docs, info: TypeDefInfo.Si, @@ -163,21 +224,10 @@ export class GenericPortableRegistry extends Struct { #extract (type: SiType, lookupIndex: number): TypeDef { const path = [...type.path]; - - // We handle ink! here as well, although we still have a different registry there - const isPrimitivePath = !!path.length && ( - ( - path.length > 2 && - path[0].eq('ink_env') && - path[1].eq('types') - ) || - PRIMITIVE_INK.includes(path[path.length - 1].toString()) || - PRIMITIVE_SP.includes(path.join('::')) - ); let typeDef: TypeDef; try { - if (isPrimitivePath) { + if (isPrimitivePath(type.path)) { typeDef = this.#extractPrimitivePath(lookupIndex, type); } else if (type.def.isArray) { typeDef = this.#extractArray(lookupIndex, type.def.asArray); @@ -330,18 +380,22 @@ export class GenericPortableRegistry extends Struct { } #extractPrimitivePath (_: number, type: SiType): TypeDef { - const displayName = type.path[type.path.length - 1].toString(); - return { - displayName, info: TypeDefInfo.Plain, - type: displayName + type: type.path[type.path.length - 1].toString() }; } #extractSequence (lookupIndex: number, { type }: SiTypeDefSequence): TypeDef { const sub = this.#createSiDef(type); + if (sub.type === 'u8') { + return { + info: TypeDefInfo.Plain, + type: 'Bytes' + }; + } + return withTypeString(this.registry, { info: TypeDefInfo.Vec, lookupIndex, diff --git a/packages/types/src/interfaces/extrinsics/definitions.ts b/packages/types/src/interfaces/extrinsics/definitions.ts index b7b28095b2..a12a12e5e2 100644 --- a/packages/types/src/interfaces/extrinsics/definitions.ts +++ b/packages/types/src/interfaces/extrinsics/definitions.ts @@ -20,6 +20,7 @@ export default { ExtrinsicPayloadUnknown: 'GenericExtrinsicPayloadUnknown', // eras + Era: 'ExtrinsicEra', ImmortalEra: 'GenericImmortalEra', MortalEra: 'GenericMortalEra', diff --git a/packages/types/src/interfaces/extrinsics/types.ts b/packages/types/src/interfaces/extrinsics/types.ts index 3841235a8a..01ba381449 100644 --- a/packages/types/src/interfaces/extrinsics/types.ts +++ b/packages/types/src/interfaces/extrinsics/types.ts @@ -13,6 +13,9 @@ export interface EcdsaSignature extends U8aFixed {} /** @name Ed25519Signature */ export interface Ed25519Signature extends H512 {} +/** @name Era */ +export interface Era extends ExtrinsicEra {} + /** @name Extrinsic */ export interface Extrinsic extends GenericExtrinsic {} diff --git a/packages/types/src/interfaces/metadata/types.ts b/packages/types/src/interfaces/metadata/types.ts index 27271b4221..4ce5c93f81 100644 --- a/packages/types/src/interfaces/metadata/types.ts +++ b/packages/types/src/interfaces/metadata/types.ts @@ -2,7 +2,7 @@ /* eslint-disable */ import type { Bytes, Enum, GenericPortableRegistry, Option, Struct, Text, Type, Vec, bool, u8 } from '@polkadot/types'; -import type { SiLookupTypeId, SiType } from '@polkadot/types/interfaces/scaleInfo'; +import type { SiField, SiLookupTypeId, SiType } from '@polkadot/types/interfaces/scaleInfo'; /** @name ErrorMetadataLatest */ export interface ErrorMetadataLatest extends ErrorMetadataV13 {} @@ -19,6 +19,15 @@ export interface ErrorMetadataV12 extends ErrorMetadataV11 {} /** @name ErrorMetadataV13 */ export interface ErrorMetadataV13 extends ErrorMetadataV12 {} +/** @name ErrorMetadataV14 */ +export interface ErrorMetadataV14 extends Struct { + readonly name: Text; + readonly fields: Vec; + readonly index: u8; + readonly docs: Vec; + readonly args: Vec; +} + /** @name ErrorMetadataV9 */ export interface ErrorMetadataV9 extends Struct { readonly name: Text; @@ -40,6 +49,15 @@ export interface EventMetadataV12 extends EventMetadataV11 {} /** @name EventMetadataV13 */ export interface EventMetadataV13 extends EventMetadataV12 {} +/** @name EventMetadataV14 */ +export interface EventMetadataV14 extends Struct { + readonly name: Text; + readonly fields: Vec; + readonly index: u8; + readonly docs: Vec; + readonly args: Vec; +} + /** @name EventMetadataV9 */ export interface EventMetadataV9 extends Struct { readonly name: Text; @@ -84,6 +102,9 @@ export interface FunctionArgumentMetadataV12 extends FunctionArgumentMetadataV11 /** @name FunctionArgumentMetadataV13 */ export interface FunctionArgumentMetadataV13 extends FunctionArgumentMetadataV12 {} +/** @name FunctionArgumentMetadataV14 */ +export interface FunctionArgumentMetadataV14 extends FunctionArgumentMetadataV13 {} + /** @name FunctionArgumentMetadataV9 */ export interface FunctionArgumentMetadataV9 extends Struct { readonly name: Text; @@ -105,6 +126,15 @@ export interface FunctionMetadataV12 extends FunctionMetadataV11 {} /** @name FunctionMetadataV13 */ export interface FunctionMetadataV13 extends FunctionMetadataV12 {} +/** @name FunctionMetadataV14 */ +export interface FunctionMetadataV14 extends Struct { + readonly name: Text; + readonly fields: Vec; + readonly index: u8; + readonly docs: Vec; + readonly args: Vec; +} + /** @name FunctionMetadataV9 */ export interface FunctionMetadataV9 extends Struct { readonly name: Text; @@ -405,9 +435,20 @@ export interface StorageEntryTypeV10 extends Enum { readonly isPlain: boolean; readonly asPlain: Type; readonly isMap: boolean; - readonly asMap: { hasher: StorageHasherV10; key: Type; value: Type; linked: bool; } & Struct; + readonly asMap: { + readonly hasher: StorageHasherV10; + readonly key: Type; + readonly value: Type; + readonly linked: bool; + } & Struct; readonly isDoubleMap: boolean; - readonly asDoubleMap: { hasher: StorageHasherV10; key1: Type; key2: Type; value: Type; key2Hasher: StorageHasherV10; } & Struct; + readonly asDoubleMap: { + readonly hasher: StorageHasherV10; + readonly key1: Type; + readonly key2: Type; + readonly value: Type; + readonly key2Hasher: StorageHasherV10; + } & Struct; } /** @name StorageEntryTypeV11 */ @@ -415,9 +456,20 @@ export interface StorageEntryTypeV11 extends Enum { readonly isPlain: boolean; readonly asPlain: Type; readonly isMap: boolean; - readonly asMap: { hasher: StorageHasherV11; key: Type; value: Type; linked: bool; } & Struct; + readonly asMap: { + readonly hasher: StorageHasherV11; + readonly key: Type; + readonly value: Type; + readonly linked: bool; + } & Struct; readonly isDoubleMap: boolean; - readonly asDoubleMap: { hasher: StorageHasherV11; key1: Type; key2: Type; value: Type; key2Hasher: StorageHasherV11; } & Struct; + readonly asDoubleMap: { + readonly hasher: StorageHasherV11; + readonly key1: Type; + readonly key2: Type; + readonly value: Type; + readonly key2Hasher: StorageHasherV11; + } & Struct; } /** @name StorageEntryTypeV12 */ @@ -428,11 +480,26 @@ export interface StorageEntryTypeV13 extends Enum { readonly isPlain: boolean; readonly asPlain: Type; readonly isMap: boolean; - readonly asMap: { hasher: StorageHasherV13; key: Type; value: Type; linked: bool; } & Struct; + readonly asMap: { + readonly hasher: StorageHasherV13; + readonly key: Type; + readonly value: Type; + readonly linked: bool; + } & Struct; readonly isDoubleMap: boolean; - readonly asDoubleMap: { hasher: StorageHasherV13; key1: Type; key2: Type; value: Type; key2Hasher: StorageHasherV13; } & Struct; + readonly asDoubleMap: { + readonly hasher: StorageHasherV13; + readonly key1: Type; + readonly key2: Type; + readonly value: Type; + readonly key2Hasher: StorageHasherV13; + } & Struct; readonly isNMap: boolean; - readonly asNMap: { keyVec: Vec; hashers: Vec; value: Type; } & Struct; + readonly asNMap: { + readonly keyVec: Vec; + readonly hashers: Vec; + readonly value: Type; + } & Struct; } /** @name StorageEntryTypeV14 */ @@ -440,11 +507,25 @@ export interface StorageEntryTypeV14 extends Enum { readonly isPlain: boolean; readonly asPlain: SiLookupTypeId; readonly isMap: boolean; - readonly asMap: { hasher: StorageHasherV14; key: SiLookupTypeId; value: SiLookupTypeId; } & Struct; + readonly asMap: { + readonly hasher: StorageHasherV14; + readonly key: SiLookupTypeId; + readonly value: SiLookupTypeId; + } & Struct; readonly isDoubleMap: boolean; - readonly asDoubleMap: { hasher: StorageHasherV14; key1: SiLookupTypeId; key2: SiLookupTypeId; value: SiLookupTypeId; key2Hasher: StorageHasherV14; } & Struct; + readonly asDoubleMap: { + readonly hasher: StorageHasherV14; + readonly key1: SiLookupTypeId; + readonly key2: SiLookupTypeId; + readonly value: SiLookupTypeId; + readonly key2Hasher: StorageHasherV14; + } & Struct; readonly isNMap: boolean; - readonly asNMap: { key: SiLookupTypeId; hashers: Vec; value: SiLookupTypeId; } & Struct; + readonly asNMap: { + readonly key: SiLookupTypeId; + readonly hashers: Vec; + readonly value: SiLookupTypeId; + } & Struct; } /** @name StorageEntryTypeV9 */ @@ -452,9 +533,20 @@ export interface StorageEntryTypeV9 extends Enum { readonly isPlain: boolean; readonly asPlain: Type; readonly isMap: boolean; - readonly asMap: { hasher: StorageHasherV9; key: Type; value: Type; linked: bool; } & Struct; + readonly asMap: { + readonly hasher: StorageHasherV9; + readonly key: Type; + readonly value: Type; + readonly linked: bool; + } & Struct; readonly isDoubleMap: boolean; - readonly asDoubleMap: { hasher: StorageHasherV9; key1: Type; key2: Type; value: Type; key2Hasher: StorageHasherV9; } & Struct; + readonly asDoubleMap: { + readonly hasher: StorageHasherV9; + readonly key1: Type; + readonly key2: Type; + readonly value: Type; + readonly key2Hasher: StorageHasherV9; + } & Struct; } /** @name StorageHasher */ diff --git a/packages/types/src/interfaces/metadata/v14.ts b/packages/types/src/interfaces/metadata/v14.ts index 0ae9be4e73..1f88d01fed 100644 --- a/packages/types/src/interfaces/metadata/v14.ts +++ b/packages/types/src/interfaces/metadata/v14.ts @@ -6,6 +6,8 @@ import type { DefinitionsTypes } from '../../types'; +import { SiVariant } from '../scaleInfo/definitions'; + export const v14: DefinitionsTypes = { // registry PortableRegistry: 'GenericPortableRegistry', @@ -14,6 +16,21 @@ export const v14: DefinitionsTypes = { type: 'SiType' }, + // compatibility with earlier layouts, i.e. don't break previous users + ErrorMetadataV14: { + ...SiVariant, + args: 'Vec' + }, + EventMetadataV14: { + ...SiVariant, + args: 'Vec' + }, + FunctionArgumentMetadataV14: 'FunctionArgumentMetadataV13', + FunctionMetadataV14: { + ...SiVariant, + args: 'Vec' + }, + // V14 ExtrinsicMetadataV14: { type: 'SiLookupTypeId', diff --git a/packages/types/src/interfaces/scaleInfo/definitions.ts b/packages/types/src/interfaces/scaleInfo/definitions.ts index a0a8261018..798b0190c6 100644 --- a/packages/types/src/interfaces/scaleInfo/definitions.ts +++ b/packages/types/src/interfaces/scaleInfo/definitions.ts @@ -8,6 +8,13 @@ import { v0 } from './v0'; // order important in structs... :) /* eslint-disable sort-keys */ +export const SiVariant = { + name: 'Text', + fields: 'Vec', + index: 'u8', + docs: 'Vec' +}; + export default { rpc: {}, types: { @@ -69,11 +76,6 @@ export default { name: 'Text', type: 'Option' }, - SiVariant: { - name: 'Text', - fields: 'Vec', - index: 'u8', - docs: 'Vec' - } + SiVariant } } as Definitions;