diff --git a/CHANGELOG.md b/CHANGELOG.md index 92a12e7b7a..50a2b3db95 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,7 +8,7 @@ - Cleanups to derives for democracy & staking to be more performant - Add Centrifuge base types to `@polkadot/types-known` - Adjust with all the latest substrate master types -- Internally all protected methods/variables are now indicated with `_` (Aligning with the `protected` indicators in the TS definitions) +- Internally all private/protected methods/variables are now indicated with `_` (Aligning with the `private/protected` indicators in the TS definitions) # 1.9.1 Apr 1, 2020 diff --git a/packages/api-contract/src/Abi.ts b/packages/api-contract/src/Abi.ts index 418878cb81..648dfcadae 100644 --- a/packages/api-contract/src/Abi.ts +++ b/packages/api-contract/src/Abi.ts @@ -18,10 +18,10 @@ export default class ContractAbi extends ContractRegistry implements InterfaceAb constructor (registry: Registry, abi: ContractABIPre) { super(registry, abi); - [this.abi, this.constructors, this.messages] = this.decodeAbi(abi); + [this.abi, this.constructors, this.messages] = this._decodeAbi(abi); } - private decodeAbi (abiPre: ContractABIPre): [ContractABI, ContractABIFn[], AbiMessages] { + private _decodeAbi (abiPre: ContractABIPre): [ContractABI, ContractABIFn[], AbiMessages] { this.validateAbi(abiPre); const abi = this.convertAbi(abiPre); diff --git a/packages/api-contract/src/MetaRegistry.ts b/packages/api-contract/src/MetaRegistry.ts index 09ed80297a..693207351a 100644 --- a/packages/api-contract/src/MetaRegistry.ts +++ b/packages/api-contract/src/MetaRegistry.ts @@ -116,7 +116,7 @@ export default class MetaRegistry extends MetadataRegistryLookup { this.typeDefs[typeIndex - 1] = this.typeDefFromMetaType(this.typeAt(typeIndex), typeIndex); } - private typeDefIdFields ({ id }: MetaType): Pick { + private _typeDefIdFields ({ id }: MetaType): Pick { const { 'custom.name': nameIndex, 'custom.namespace': namespaceIndices, 'custom.params': paramsIndices } = id as MetaTypeIdCustom; if (!nameIndex) { @@ -136,33 +136,33 @@ export default class MetaRegistry extends MetadataRegistryLookup { }; } - private typeDefDefFields (metaType: MetaType, typeIndex?: TypeIndex): Pick { + private _typeDefDefFields (metaType: MetaType, typeIndex?: TypeIndex): Pick { let typeDef; switch (detectedType(metaType)) { case MetaTypeInfo.BuiltinPlain: - typeDef = this.typeDefForBuiltinPlain(metaType.id as string); + typeDef = this._typeDefForBuiltinPlain(metaType.id as string); break; case MetaTypeInfo.BuiltinTuple: - typeDef = this.typeDefForBuiltinTuple(metaType.id as TypeIndex[]); + typeDef = this._typeDefForBuiltinTuple(metaType.id as TypeIndex[]); break; case MetaTypeInfo.BuiltinVec: - typeDef = this.typeDefForBuiltinVec(metaType.id as MetaTypeIdVec, typeIndex); + typeDef = this._typeDefForBuiltinVec(metaType.id as MetaTypeIdVec, typeIndex); break; case MetaTypeInfo.BuiltinVecFixed: - typeDef = this.typeDefForBuiltinVecFixed(metaType.id as MetaTypeIdVecFixed, typeIndex); + typeDef = this._typeDefForBuiltinVecFixed(metaType.id as MetaTypeIdVecFixed, typeIndex); break; case MetaTypeInfo.Enum: - typeDef = this.typeDefForEnum(metaType.def as MetaTypeDefEnum, metaType.id as MetaTypeIdCustom, typeIndex); + typeDef = this._typeDefForEnum(metaType.def as MetaTypeDefEnum, metaType.id as MetaTypeIdCustom, typeIndex); break; case MetaTypeInfo.ClikeEnum: - typeDef = this.typeDefForClikeEnum(metaType.def as MetaTypeDefClikeEnum); + typeDef = this._typeDefForClikeEnum(metaType.def as MetaTypeDefClikeEnum); break; case MetaTypeInfo.Struct: typeDef = this.typeDefForStruct(metaType.def as MetaTypeDefStruct); break; case MetaTypeInfo.TupleStruct: - typeDef = this.typeDefForTupleStruct(metaType.def as MetaTypeDefTupleStruct); + typeDef = this._typeDefForTupleStruct(metaType.def as MetaTypeDefTupleStruct); break; case MetaTypeInfo.Null: default: @@ -176,8 +176,8 @@ export default class MetaRegistry extends MetadataRegistryLookup { return withTypeString({ info: TypeDefInfo.Null, type: '', - ...this.typeDefDefFields(metaType, typeIndex), - ...this.typeDefIdFields(metaType) + ...this._typeDefDefFields(metaType, typeIndex), + ...this._typeDefIdFields(metaType) }) as TypeDef; } @@ -189,7 +189,7 @@ export default class MetaRegistry extends MetadataRegistryLookup { return this.typeDefAt(typeIndex); } - private typeDefForEnumVariant (variant: MetaTypeDefEnumVariant): Pick { + private _typeDefForEnumVariant (variant: MetaTypeDefEnumVariant): Pick { const { 'unit_variant.name': unitNameIndex } = variant as MetaTypeDefEnumVariantUnit; if (unitNameIndex) { @@ -203,7 +203,7 @@ export default class MetaRegistry extends MetadataRegistryLookup { const { 'tuple_struct_variant.name': tupleStructVariantNameIndex } = variant as MetaTypeDefEnumVariantTupleStruct; if (tupleStructVariantNameIndex) { - return this.typeDefForTupleStruct(variant as MetaTypeDefEnumVariantTupleStruct); + return this._typeDefForTupleStruct(variant as MetaTypeDefEnumVariantTupleStruct); } const { 'struct_variant.name': structVariantNameIndex } = variant as MetaTypeDefEnumVariantStruct; @@ -218,14 +218,14 @@ export default class MetaRegistry extends MetadataRegistryLookup { }; } - private typeDefForBuiltinPlain (id: string): Pick { + private _typeDefForBuiltinPlain (id: string): Pick { return { info: TypeDefInfo.Plain, type: id }; } - private typeDefForBuiltinTuple (id: TypeIndex[]): Pick { + private _typeDefForBuiltinTuple (id: TypeIndex[]): Pick { const sub = id.map((tupleTypeIndex: number): TypeDef => this.typeDefFromMetaTypeAt(tupleTypeIndex)); return { @@ -234,7 +234,7 @@ export default class MetaRegistry extends MetadataRegistryLookup { }; } - private typeDefForBuiltinVec (id: MetaTypeIdVec, typeIndex?: TypeIndex): Pick { + private _typeDefForBuiltinVec (id: MetaTypeIdVec, typeIndex?: TypeIndex): Pick { const { 'slice.type': vecTypeIndex } = id; assert(!typeIndex || vecTypeIndex !== typeIndex, `MetaRegistry: self-referencing registry type at index ${typeIndex}`); @@ -250,7 +250,7 @@ export default class MetaRegistry extends MetadataRegistryLookup { }; } - private typeDefForBuiltinVecFixed (id: MetaTypeIdVecFixed, typeIndex?: TypeIndex): Pick { + private _typeDefForBuiltinVecFixed (id: MetaTypeIdVecFixed, typeIndex?: TypeIndex): Pick { const { 'array.len': vecLength, 'array.type': vecTypeIndex } = id; assert(!vecLength || vecLength <= 256, 'MetaRegistry: Only support for [Type; ], where length <= 256'); @@ -268,7 +268,7 @@ export default class MetaRegistry extends MetadataRegistryLookup { }; } - private typeDefForEnum (def: MetaTypeDefEnum, id: MetaTypeIdCustom, typeIndex?: TypeIndex): Pick { + private _typeDefForEnum (def: MetaTypeDefEnum, id: MetaTypeIdCustom, typeIndex?: TypeIndex): Pick { const name = id && this._stringAt(id['custom.name']); switch (name) { @@ -279,7 +279,7 @@ export default class MetaRegistry extends MetadataRegistryLookup { return this.typeDefForResult(id, typeIndex); default: { - const sub = def['enum.variants'].map((variant) => this.typeDefForEnumVariant(variant)); + const sub = def['enum.variants'].map((variant) => this._typeDefForEnumVariant(variant)); return { info: TypeDefInfo.Enum, @@ -289,7 +289,7 @@ export default class MetaRegistry extends MetadataRegistryLookup { } } - private typeDefForClikeEnum (def: MetaTypeDefClikeEnum): Pick { + private _typeDefForClikeEnum (def: MetaTypeDefClikeEnum): Pick { return { info: TypeDefInfo.Enum, sub: def['clike_enum.variants'].map(({ discriminant, name: nameIndex }): TypeDef => ({ @@ -336,7 +336,7 @@ export default class MetaRegistry extends MetadataRegistryLookup { }); } - private typeDefForTupleStruct (def: MetaTypeDefTupleStruct | MetaTypeDefEnumVariantTupleStruct): Pick { + private _typeDefForTupleStruct (def: MetaTypeDefTupleStruct | MetaTypeDefEnumVariantTupleStruct): Pick { const tupleStructTypes = (def as MetaTypeDefTupleStruct)['tuple_struct.types'] || (def as MetaTypeDefEnumVariantTupleStruct)['tuple_struct_variant.types']; const tupleStructNameIndex = (def as MetaTypeDefEnumVariantTupleStruct)['tuple_struct_variant.name']; diff --git a/packages/api-contract/src/base/Blueprint.ts b/packages/api-contract/src/base/Blueprint.ts index 789ad47482..e83e021eae 100644 --- a/packages/api-contract/src/base/Blueprint.ts +++ b/packages/api-contract/src/base/Blueprint.ts @@ -52,13 +52,13 @@ export default class Blueprint extends BaseWithTx => { + private _createResult = (result: SubmittableResult): BlueprintCreateResult => { let contract: Contract | undefined; if (result.isInBlock) { diff --git a/packages/api-contract/src/base/Code.ts b/packages/api-contract/src/base/Code.ts index 0c693e2227..c4b531953b 100644 --- a/packages/api-contract/src/base/Code.ts +++ b/packages/api-contract/src/base/Code.ts @@ -51,12 +51,12 @@ export default class Code extends BaseWithTx this._apiContracts .putCode(maxGas, compactAddLength(this.code)) .signAndSend(account) - .pipe(map(this.createResult)) + .pipe(map(this._createResult)) ) }; } - private createResult = (result: ISubmittableResult): CodePutCodeResult => { + private _createResult = (result: ISubmittableResult): CodePutCodeResult => { let blueprint: Blueprint | undefined; if (result.isInBlock) { diff --git a/packages/api-contract/src/base/Contract.ts b/packages/api-contract/src/base/Contract.ts index 024e9f873d..8f2a34373f 100644 --- a/packages/api-contract/src/base/Contract.ts +++ b/packages/api-contract/src/base/Contract.ts @@ -33,6 +33,12 @@ export type ContractCallResult = CallType ex export default class Contract extends BaseWithTxAndRpcCall { public readonly address: Address; + constructor (api: ApiObject, abi: ContractABIPre | Abi, decorateMethod: DecorateMethod, address: string | AccountId | Address) { + super(api, abi, decorateMethod); + + this.address = this.registry.createType('Address', address); + } + public call (as: 'rpc', message: string, value: BN | number, gasLimit: BN | number, ...params: any[]): ContractCall; public call (as: 'tx', message: string, value: BN | number, gasLimit: BN | number, ...params: any[]): ContractCall; public call (as: CallType, message: string, value: BN | number, gasLimit: BN | number, ...params: any[]): ContractCall { @@ -51,7 +57,7 @@ export default class Contract extends BaseWithTxAndRpc value }) ).pipe(map((result: ContractExecResult): ContractCallOutcome => - this.createOutcome(result, this.registry.createType('AccountId', account), def, params) + this._createOutcome(result, this.registry.createType('AccountId', account), def, params) )) : (account: IKeyringPair | string | AccountId | Address): ContractCallResult<'tx'> => this._apiContracts @@ -61,7 +67,7 @@ export default class Contract extends BaseWithTxAndRpc }; } - private createOutcome (result: ContractExecResult, origin: AccountId, message: ContractABIMessage, params: any[]): ContractCallOutcome { + private _createOutcome (result: ContractExecResult, origin: AccountId, message: ContractABIMessage, params: any[]): ContractCallOutcome { let output: Codec | null = null; if (result.isSuccess) { @@ -82,10 +88,4 @@ export default class Contract extends BaseWithTxAndRpc time: Date.now() }; } - - constructor (api: ApiObject, abi: ContractABIPre | Abi, decorateMethod: DecorateMethod, address: string | AccountId | Address) { - super(api, abi, decorateMethod); - - this.address = this.registry.createType('Address', address); - } } diff --git a/packages/api-derive/src/type/HeaderExtended.ts b/packages/api-derive/src/type/HeaderExtended.ts index fbade1ba1b..4e34c2ed75 100644 --- a/packages/api-derive/src/type/HeaderExtended.ts +++ b/packages/api-derive/src/type/HeaderExtended.ts @@ -22,10 +22,10 @@ export default class HeaderExtended extends _Header { constructor (registry: Registry, header?: Header, sessionValidators?: AccountId[]) { super(registry, header); - this.#author = this.extractAuthor(sessionValidators); + this.#author = this._extractAuthor(sessionValidators); } - private extractAuthor (sessionValidators: AccountId[] = []): AccountId | undefined { + private _extractAuthor (sessionValidators: AccountId[] = []): AccountId | undefined { const [pitem] = this.digest.logsWith('PreRuntime'); // extract from the substrate 2.0 PreRuntime digest diff --git a/packages/api/src/base/Decorate.ts b/packages/api/src/base/Decorate.ts index 3a7d8c35f5..f4fb312590 100644 --- a/packages/api/src/base/Decorate.ts +++ b/packages/api/src/base/Decorate.ts @@ -184,7 +184,7 @@ export default abstract class Decorate extends Events augmentObject('', decoratedMeta.consts, this._rx.consts, fromEmpty); } - private decorateFunctionMeta (input: MetaDecoration, output: MetaDecoration): MetaDecoration { + private _decorateFunctionMeta (input: MetaDecoration, output: MetaDecoration): MetaDecoration { output.meta = input.meta; output.method = input.method; output.section = input.section; @@ -300,7 +300,7 @@ export default abstract class Decorate extends Events const decorated = (...params: Arg[]): SubmittableExtrinsic => creator(method(...params)); - return this.decorateFunctionMeta(method, decorated as any) as SubmittableExtrinsicFunction; + return this._decorateFunctionMeta(method, decorated as any) as SubmittableExtrinsicFunction; } protected _decorateStorage (storage: Storage, decorateMethod: DecorateMethod): QueryableStorage { @@ -321,7 +321,7 @@ export default abstract class Decorate extends Events // FIXME We probably want to be able to query the full list with non-subs as well const decorated = this.hasSubscriptions && creator.iterKey && creator.meta.type.isMap && creator.meta.type.asMap.linked.isTrue - ? this.decorateStorageLinked(creator, decorateMethod) + ? this._decorateStorageLinked(creator, decorateMethod) : decorateMethod((...args: any[]): Observable => ( this.hasSubscriptions ? this._rpcCore.state @@ -348,7 +348,7 @@ export default abstract class Decorate extends Events u8aToHex(creator.keyPrefix); decorated.range = decorateMethod((range: [Hash, Hash?], arg1?: Arg, arg2?: Arg): Observable<[Hash, Codec][]> => - this.decorateStorageRange(decorated, [arg1, arg2], range)); + this._decorateStorageRange(decorated, [arg1, arg2], range)); decorated.size = decorateMethod((arg1?: Arg, arg2?: Arg): Observable => this._rpcCore.state.getStorageSize(getArgs(arg1, arg2))); @@ -357,11 +357,11 @@ export default abstract class Decorate extends Events if (creator.iterKey && (creator.meta.type.isMap || creator.meta.type.isDoubleMap)) { decorated.entries = decorateMethod( memo((doubleMapArg?: Arg): Observable<[StorageKey, Codec][]> => - this.retrieveMapEntries(creator, doubleMapArg))); + this._retrieveMapEntries(creator, doubleMapArg))); decorated.keys = decorateMethod( memo((doubleMapArg?: Arg): Observable => - this.retrieveMapKeys(creator, doubleMapArg))); + this._retrieveMapKeys(creator, doubleMapArg))); } // only support multi where subs are available @@ -372,10 +372,10 @@ export default abstract class Decorate extends Events args.map((arg: Arg[] | Arg): [StorageEntry, Arg | Arg[]] => [creator, arg]))); } - return this.decorateFunctionMeta(creator, decorated) as unknown as QueryableStorageEntry; + return this._decorateFunctionMeta(creator, decorated) as unknown as QueryableStorageEntry; } - private decorateStorageRange (decorated: QueryableStorageEntry, args: [Arg?, Arg?], range: [Hash, Hash?]): Observable<[Hash, Codec][]> { + private _decorateStorageRange (decorated: QueryableStorageEntry, args: [Arg?, Arg?], range: [Hash, Hash?]): Observable<[Hash, Codec][]> { const outputType = unwrapStorageType(decorated.creator.meta.type, decorated.creator.meta.modifier.isOptional); return this._rpcCore.state @@ -388,7 +388,7 @@ export default abstract class Decorate extends Events )); } - private decorateStorageLinked (creator: StorageEntry, decorateMethod: DecorateMethod): ReturnType> { + private _decorateStorageLinked (creator: StorageEntry, decorateMethod: DecorateMethod): ReturnType> { const result: Map]> | null> = new Map(); let subject: BehaviorSubject; let head: Codec | null = null; @@ -460,7 +460,7 @@ export default abstract class Decorate extends Events ); } - private retrieveMapKeys ({ iterKey, meta }: StorageEntry, arg?: Arg): Observable { + private _retrieveMapKeys ({ iterKey, meta }: StorageEntry, arg?: Arg): Observable { assert(iterKey && (meta.type.isMap || meta.type.isDoubleMap), 'keys can only be retrieved on maps, linked maps and double maps'); const headKey = this.createType('Raw', u8aConcat( @@ -493,10 +493,10 @@ export default abstract class Decorate extends Events ); } - private retrieveMapEntries (entry: StorageEntry, arg?: Arg): Observable<[StorageKey, Codec][]> { + private _retrieveMapEntries (entry: StorageEntry, arg?: Arg): Observable<[StorageKey, Codec][]> { const outputType = unwrapStorageType(entry.meta.type, entry.meta.modifier.isOptional); - return this.retrieveMapKeys(entry, arg).pipe( + return this._retrieveMapKeys(entry, arg).pipe( switchMap((keys): Observable<[StorageKey[], Option[][]]> => combineLatest([ of(keys), diff --git a/packages/api/src/base/Init.ts b/packages/api/src/base/Init.ts index 09279f2576..4a37db3f61 100644 --- a/packages/api/src/base/Init.ts +++ b/packages/api/src/base/Init.ts @@ -89,14 +89,14 @@ export default abstract class Init extends Decorate): Promise { + private async _metaFromSource (source: ApiBase): Promise { this._extrinsicType = source.extrinsicVersion; this._runtimeVersion = source.runtimeVersion; this._genesisHash = source.genesisHash; @@ -118,7 +118,7 @@ export default abstract class Init extends Decorate extends Decorate): Promise { + private async _metaFromChain (optMetadata: Record): Promise { const [runtimeVersion, chain, chainProps] = await Promise.all([ this._rpcCore.state.getRuntimeVersion().toPromise(), this._rpcCore.system.chain().toPromise(), @@ -162,7 +162,7 @@ export default abstract class Init extends Decorate extends Decorate { + private async _initFromMeta (metadata: Metadata): Promise { // inject types based on metadata, if applicable this.registerTypes(getMetadataTypes(this.registry, metadata.version)); diff --git a/packages/api/test/util/SingleAccountSigner.ts b/packages/api/test/util/SingleAccountSigner.ts index 81d1867b05..0cc97f93f7 100644 --- a/packages/api/test/util/SingleAccountSigner.ts +++ b/packages/api/test/util/SingleAccountSigner.ts @@ -11,49 +11,49 @@ import { hexToU8a, u8aToHex } from '@polkadot/util'; let id = 0; export class SingleAccountSigner implements Signer { - private keyringPair: KeyringPair; + readonly #keyringPair: KeyringPair; - private registry: Registry; + readonly #registry: Registry; - private signDelay: number; + readonly #signDelay: number; constructor (registry: Registry, keyringPair: KeyringPair, signDelay = 0) { - this.keyringPair = keyringPair; - this.registry = registry; - this.signDelay = signDelay; + this.#keyringPair = keyringPair; + this.#registry = registry; + this.#signDelay = signDelay; } public async signPayload (payload: SignerPayloadJSON): Promise { - if (payload.address !== this.keyringPair.address) { + if (payload.address !== this.#keyringPair.address) { throw new Error('does not have the keyringPair'); } return new Promise((resolve): void => { setTimeout((): void => { - const signed = this.registry.createType('ExtrinsicPayload', payload, { version: payload.version }).sign(this.keyringPair); + const signed = this.#registry.createType('ExtrinsicPayload', payload, { version: payload.version }).sign(this.#keyringPair); resolve({ id: ++id, ...signed }); - }, this.signDelay); + }, this.#signDelay); }); } public async signRaw ({ address, data }: SignerPayloadRaw): Promise { - if (address !== this.keyringPair.address) { + if (address !== this.#keyringPair.address) { throw new Error('does not have the keyringPair'); } return new Promise((resolve): void => { setTimeout((): void => { - const signature = u8aToHex(this.keyringPair.sign(hexToU8a(data))); + const signature = u8aToHex(this.#keyringPair.sign(hexToU8a(data))); resolve({ id: ++id, signature }); - }, this.signDelay); + }, this.#signDelay); }); } } diff --git a/packages/metadata/src/Metadata/MetadataVersioned.ts b/packages/metadata/src/Metadata/MetadataVersioned.ts index c33689c3fc..bf15ce20ff 100644 --- a/packages/metadata/src/Metadata/MetadataVersioned.ts +++ b/packages/metadata/src/Metadata/MetadataVersioned.ts @@ -44,18 +44,18 @@ export default class MetadataVersioned extends Struct { registry.setMetadata(this); } - private assertVersion (version: number): boolean { + private _assertVersion (version: number): boolean { assert(this.version <= version, `Cannot convert metadata from v${this.version} to v${version}`); return this.version === version; } - private getVersion (version: MetaVersions, fromPrev: (registry: Registry, input: F) => T): T { + private _getVersion (version: MetaVersions, fromPrev: (registry: Registry, input: F) => T): T { const asCurr = `asV${version}` as MetaAsX; const asPrev = `asV${version - 1}` as MetaAsX; - if (this.assertVersion(version)) { - return this.metadata[asCurr] as T; + if (this._assertVersion(version)) { + return this._metadata[asCurr] as T; } if (!this.#converted.has(version)) { @@ -79,86 +79,86 @@ export default class MetadataVersioned extends Struct { * @description Returns the wrapped metadata as a V0 object */ public get asV0 (): MetadataV0 { - this.assertVersion(0); + this._assertVersion(0); - return this.metadata.asV0; + return this._metadata.asV0; } /** * @description Returns the wrapped values as a V1 object */ public get asV1 (): MetadataV1 { - return this.getVersion(1, v0ToV1); + return this._getVersion(1, v0ToV1); } /** * @description Returns the wrapped values as a V2 object */ public get asV2 (): MetadataV2 { - return this.getVersion(2, v1ToV2); + return this._getVersion(2, v1ToV2); } /** * @description Returns the wrapped values as a V3 object */ public get asV3 (): MetadataV3 { - return this.getVersion(3, v2ToV3); + return this._getVersion(3, v2ToV3); } /** * @description Returns the wrapped values as a V4 object */ public get asV4 (): MetadataV4 { - return this.getVersion(4, v3ToV4); + return this._getVersion(4, v3ToV4); } /** * @description Returns the wrapped values as a V5 object */ public get asV5 (): MetadataV5 { - return this.getVersion(5, v4ToV5); + return this._getVersion(5, v4ToV5); } /** * @description Returns the wrapped values as a V6 object */ public get asV6 (): MetadataV6 { - return this.getVersion(6, v5ToV6); + return this._getVersion(6, v5ToV6); } /** * @description Returns the wrapped values as a V7 object */ public get asV7 (): MetadataV7 { - return this.getVersion(7, v6ToV7); + return this._getVersion(7, v6ToV7); } /** * @description Returns the wrapped values as a V8 object */ public get asV8 (): MetadataV8 { - return this.getVersion(8, v7ToV8); + return this._getVersion(8, v7ToV8); } /** * @description Returns the wrapped values as a V9 object */ public get asV9 (): MetadataV9 { - return this.getVersion(9, v8ToV9); + return this._getVersion(9, v8ToV9); } /** * @description Returns the wrapped values as a V10 object */ public get asV10 (): MetadataV10 { - return this.getVersion(10, v9ToV10); + return this._getVersion(10, v9ToV10); } /** * @description Returns the wrapped values as a V10 object */ public get asV11 (): MetadataV11 { - return this.getVersion(11, v10ToV11); + return this._getVersion(11, v10ToV11); } /** @@ -166,7 +166,7 @@ export default class MetadataVersioned extends Struct { */ public get asLatest (): MetadataLatest { // This is non-existent & latest - applied here to do the module-specific type conversions - return this.getVersion(12, v11ToLatest); + return this._getVersion(12, v11ToLatest); } /** @@ -179,7 +179,7 @@ export default class MetadataVersioned extends Struct { /** * @description the metadata wrapped */ - private get metadata (): MetadataAll { + private get _metadata (): MetadataAll { return this.get('metadata') as MetadataAll; } @@ -187,7 +187,7 @@ export default class MetadataVersioned extends Struct { * @description the metadata version this structure represents */ public get version (): number { - return this.metadata.index; + return this._metadata.index; } public getUniqTypes (throwError: boolean): string[] { diff --git a/packages/rpc-core/src/index.ts b/packages/rpc-core/src/index.ts index 552e40ebff..a3d9aae98e 100644 --- a/packages/rpc-core/src/index.ts +++ b/packages/rpc-core/src/index.ts @@ -111,7 +111,7 @@ export default class Rpc implements RpcInterface { this.registry = registry; this.provider = provider; - this.createInterfaces(userRpc); + this._createInterfaces(userRpc); } /** @@ -121,7 +121,7 @@ export default class Rpc implements RpcInterface { this.provider.disconnect(); } - private createInterfaces
(userRpc: Record>): void { + private _createInterfaces
(userRpc: Record>): void { const sectionNames = Object.keys(jsonrpc); // these are the base keys (i.e. part of jsonrpc) @@ -133,13 +133,13 @@ export default class Rpc implements RpcInterface { // decorate the sections with base and user methods this.sections.forEach((sectionName): void => { (this as any)[sectionName as Section] = { - ...this.createInterface(sectionName, jsonrpc[sectionName as 'babe'] || {}), - ...this.createInterface(sectionName, userRpc[sectionName] || {}) + ...this._createInterface(sectionName, jsonrpc[sectionName as 'babe'] || {}), + ...this._createInterface(sectionName, userRpc[sectionName] || {}) }; }); } - private createInterface
(section: string, methods: Record): RpcInterface[Section] { + private _createInterface
(section: string, methods: Record): RpcInterface[Section] { return Object .keys(methods) .reduce((exposed, method): RpcInterface[Section] => { @@ -155,14 +155,14 @@ export default class Rpc implements RpcInterface { // Not doing so, because it makes this class a little bit less readable, // and leaving it as-is doesn't harm much (exposed as any)[method] = isSubscription - ? this.createMethodSubscribe(section, method, def as DefinitionRpcSub) - : this.createMethodSend(section, method, def); + ? this._createMethodSubscribe(section, method, def as DefinitionRpcSub) + : this._createMethodSend(section, method, def); return exposed; }, {} as RpcInterface[Section]); } - private createMethodWithRaw (creator: (isRaw: boolean) => (...values: any[]) => Observable): RpcInterfaceMethod { + private _createMethodWithRaw (creator: (isRaw: boolean) => (...values: any[]) => Observable): RpcInterfaceMethod { const call = creator(false) as Partial; call.raw = creator(true); @@ -170,7 +170,7 @@ export default class Rpc implements RpcInterface { return call as RpcInterfaceMethod; } - private createMethodSend (section: string, method: string, def: DefinitionRpc): RpcInterfaceMethod { + private _createMethodSend (section: string, method: string, def: DefinitionRpc): RpcInterfaceMethod { const rpcName = `${section}_${method}`; const creator = (isRaw: boolean) => (...values: any[]): Observable => { @@ -181,7 +181,7 @@ export default class Rpc implements RpcInterface { // - first do `of(1)` - won't throw // - then do `map(()=>this.formatInputs)` - might throw, but inside Observable. return of(1).pipe( - map(() => this.formatInputs(def, values)), + map(() => this._formatInputs(def, values)), switchMap((params): Observable<[Codec[], any]> => combineLatest([ of(params), @@ -191,7 +191,7 @@ export default class Rpc implements RpcInterface { map(([params, result]) => isRaw ? this.registry.createType('Raw', result) - : this.formatOutput(method, def, params, result) + : this._formatOutput(method, def, params, result) ), catchError((error): any => { logErrorMessage(method, def, error); @@ -206,11 +206,11 @@ export default class Rpc implements RpcInterface { // We voluntarily don't cache the "one-shot" RPC calls. For example, // `getStorage('123')` returns the current value, but this value can change // over time, so we wouldn't want to cache the Observable. - return this.createMethodWithRaw(creator); + return this._createMethodWithRaw(creator); } // create a subscriptor, it subscribes once and resolves with the id as subscribe - private createSubscriber ({ paramsJson, subName, subType, update }: { subType: string; subName: string; paramsJson: AnyJson[]; update: ProviderInterfaceCallback }, errorHandler: (error: Error) => void): Promise { + private _createSubscriber ({ paramsJson, subName, subType, update }: { subType: string; subName: string; paramsJson: AnyJson[]; update: ProviderInterfaceCallback }, errorHandler: (error: Error) => void): Promise { return new Promise((resolve, reject): void => { this.provider .subscribe(subType, subName, paramsJson, update) @@ -222,7 +222,7 @@ export default class Rpc implements RpcInterface { }); } - private createMethodSubscribe (section: string, method: string, def: DefinitionRpcSub): RpcInterfaceMethod { + private _createMethodSubscribe (section: string, method: string, def: DefinitionRpcSub): RpcInterfaceMethod { const [updateType, subMethod, unsubMethod] = def.pubsub; const subName = `${section}_${subMethod}`; const unsubName = `${section}_${unsubMethod}`; @@ -240,7 +240,7 @@ export default class Rpc implements RpcInterface { }; try { - const params = this.formatInputs(def, values); + const params = this._formatInputs(def, values); const paramsJson = params.map((param): AnyJson => param.toJSON()); const update = (error?: Error | null, result?: any): void => { @@ -254,14 +254,14 @@ export default class Rpc implements RpcInterface { observer.next( isRaw ? this.registry.createType('Raw', result) - : this.formatOutput(method, def, params, result) + : this._formatOutput(method, def, params, result) ); } catch (error) { observer.error(error); } }; - subscriptionPromise = this.createSubscriber({ paramsJson, subName, subType, update }, errorHandler); + subscriptionPromise = this._createSubscriber({ paramsJson, subName, subType, update }, errorHandler); } catch (error) { errorHandler(error); } @@ -292,7 +292,7 @@ export default class Rpc implements RpcInterface { }).pipe(drr()); }; - const memoized = memoizee(this.createMethodWithRaw(creator), { + const memoized = memoizee(this._createMethodWithRaw(creator), { // Dynamic length for argument length: false, // Normalize args so that different args that should be cached @@ -305,7 +305,7 @@ export default class Rpc implements RpcInterface { return memoized; } - private formatInputs (def: DefinitionRpc, inputs: any[]): Codec[] { + private _formatInputs (def: DefinitionRpc, inputs: any[]): Codec[] { const reqArgCount = def.params.filter(({ isOptional }): boolean => !isOptional).length; const optText = reqArgCount === def.params.length ? '' @@ -318,29 +318,29 @@ export default class Rpc implements RpcInterface { ); } - private treatAsHex (key: StorageKey): boolean { + private _treatAsHex (key: StorageKey): boolean { // :code is problematic - it does not have the length attached, which is // unlike all other storage entries where it is indeed properly encoded return ['0x3a636f6465'].includes(key.toHex()); } - private formatOutput (method: string, rpc: DefinitionRpc, params: Codec[], result?: any): Codec | Codec[] { + private _formatOutput (method: string, rpc: DefinitionRpc, params: Codec[], result?: any): Codec | Codec[] { if (rpc.type === 'StorageData') { const key = params[0] as StorageKey; try { - return this.formatStorageData(key, result); + return this._formatStorageData(key, result); } catch (error) { console.error(`Unable to decode storage ${key.section}.${key.method}:`, error.message); throw error; } } else if (rpc.type === 'StorageChangeSet') { - return this.formatStorageSet(params[0] as Vec, result.changes); + return this._formatStorageSet(params[0] as Vec, result.changes); } else if (rpc.type === 'Vec') { const mapped = result.map(({ block, changes }: { block: string; changes: [string, string | null][] }): [Hash, Codec[]] => [ this.registry.createType('Hash', block), - this.formatStorageSet(params[0] as Vec, changes) + this._formatStorageSet(params[0] as Vec, changes) ]); // we only query at a specific block, not a range - flatten @@ -352,7 +352,7 @@ export default class Rpc implements RpcInterface { return createTypeUnsafe(this.registry, rpc.type, [result]); } - private formatStorageData (key: StorageKey, value: string | null): Codec { + private _formatStorageData (key: StorageKey, value: string | null): Codec { // single return value (via state.getStorage), decode the value based on the // outputType that we have specified. Fallback to Raw on nothing const type = key.outputType || 'Raw'; @@ -363,7 +363,7 @@ export default class Rpc implements RpcInterface { // data will be correctly encoded (incl. numbers, excl. :code) const input = isEmpty ? null - : this.treatAsHex(key) + : this._treatAsHex(key) ? value : u8aToU8a(value); @@ -386,7 +386,7 @@ export default class Rpc implements RpcInterface { ], true); } - private formatStorageSet (keys: Vec, changes: [string, string | null][]): Codec[] { + private _formatStorageSet (keys: Vec, changes: [string, string | null][]): Codec[] { // For StorageChangeSet, the changes has the [key, value] mappings const withCache = keys.length !== 1; @@ -396,7 +396,7 @@ export default class Rpc implements RpcInterface { // - null - The storage key is empty return keys.reduce((results: Codec[], key: StorageKey): Codec[] => { try { - results.push(this.formatStorageSetEntry(key, changes, withCache)); + results.push(this._formatStorageSetEntry(key, changes, withCache)); } catch (error) { console.error(`Unable to decode storage ${key.section}.${key.method}:`, error.message); @@ -407,7 +407,7 @@ export default class Rpc implements RpcInterface { }, []); } - private formatStorageSetEntry (key: StorageKey, changes: [string, string | null][], witCache: boolean): Codec { + private _formatStorageSetEntry (key: StorageKey, changes: [string, string | null][], witCache: boolean): Codec { // Fallback to Raw (i.e. just the encoding) if we don't have a specific type const type = key.outputType || 'Raw'; const hexKey = key.toHex(); @@ -422,7 +422,7 @@ export default class Rpc implements RpcInterface { ? (witCache && this.#storageCache.get(hexKey)) || null : found[1]; const isEmpty = isNull(value); - const input = isEmpty || this.treatAsHex(key) + const input = isEmpty || this._treatAsHex(key) ? value : u8aToU8a(value); diff --git a/packages/rpc-core/src/methodSend.spec.ts b/packages/rpc-core/src/methodSend.spec.ts index c79b3864bc..4e6bc8b7ab 100644 --- a/packages/rpc-core/src/methodSend.spec.ts +++ b/packages/rpc-core/src/methodSend.spec.ts @@ -41,7 +41,7 @@ describe('methodSend', (): void => { it('checks for mismatched parameters', (done): void => { // private method - const method = (rpc as any).createMethodSend('test', 'bleh', methods.bleh); + const method = (rpc as any)._createMethodSend('test', 'bleh', methods.bleh); method(1).subscribe( (): void => undefined, @@ -53,7 +53,7 @@ describe('methodSend', (): void => { it('calls the provider with the correct parameters', (done): void => { // private method - const method = (rpc as any).createMethodSend('test', 'blah', methods.blah); + const method = (rpc as any)._createMethodSend('test', 'blah', methods.blah); // Args are length-prefixed, because it's a Bytes method(new Uint8Array([2 << 2, 0x12, 0x34])).subscribe((): void => { diff --git a/packages/rpc-provider/src/coder/index.ts b/packages/rpc-provider/src/coder/index.ts index 6a3690601f..f6a46e0897 100644 --- a/packages/rpc-provider/src/coder/index.ts +++ b/packages/rpc-provider/src/coder/index.ts @@ -32,12 +32,12 @@ export default class RpcCoder { assert(isNumber(response.id) || (isSubscription && isNumber(response.params.subscription)), 'Invalid id field in decoded object'); - this.checkError(response.error); + this._checkError(response.error); assert(!isUndefined(response.result) || isSubscription, 'No result found in JsonRpc response'); if (isSubscription) { - this.checkError(response.params.error); + this._checkError(response.params.error); return response.params.result; } @@ -64,7 +64,7 @@ export default class RpcCoder { return this.#id; } - private checkError (error?: JsonRpcResponseBaseError): void { + private _checkError (error?: JsonRpcResponseBaseError): void { if (error) { const { code, data, message } = error; diff --git a/packages/types/src/codec/AbstractInt.ts b/packages/types/src/codec/AbstractInt.ts index cf0fae10b2..b3aa3ee861 100644 --- a/packages/types/src/codec/AbstractInt.ts +++ b/packages/types/src/codec/AbstractInt.ts @@ -15,6 +15,36 @@ export type UIntBitLength = 8 | 16 | 32 | 64 | 128 | 256; export const DEFAULT_UINT_BITS = 64; +/** @internal */ +function decodeAbstracIntU8a (value: Uint8Array, bitLength: UIntBitLength, isNegative: boolean): string { + if (!value.length) { + return '0'; + } + + try { + // NOTE When passing u8a in (typically from decoded data), it is always Little Endian + return u8aToBn(value.subarray(0, bitLength / 8), { isLe: true, isNegative }).toString(); + } catch (error) { + throw new Error(`AbstractInt: failed on ${JSON.stringify(value)}:: ${error.message}`); + } +} + +/** @internal */ +function decodeAbstracInt (value: AnyNumber, bitLength: UIntBitLength, isNegative: boolean): string { + // This function returns a string, which will be passed in the BN + // constructor. It would be ideal to actually return a BN, but there's a + // bug: https://github.com/indutny/bn.js/issues/206. + if (isHex(value, -1, true)) { + return hexToBn(value, { isLe: false, isNegative }).toString(); + } else if (isU8a(value)) { + return decodeAbstracIntU8a(value, bitLength, isNegative); + } else if (isString(value)) { + return new BN(value.toString(), 10).toString(); + } + + return bnToBn(value).toString(); +} + /** * @name AbstractInt * @ignore @@ -32,7 +62,7 @@ export default abstract class AbstractInt extends BN implements Codec { readonly #isSigned: boolean; protected constructor (registry: Registry, isSigned: boolean, value: AnyNumber = 0, bitLength: UIntBitLength = DEFAULT_UINT_BITS, isHexJson = true) { - super(AbstractInt.decodeAbstracInt(value, bitLength, isSigned)); + super(decodeAbstracInt(value, bitLength, isSigned)); this.registry = registry; this.#bitLength = bitLength; @@ -42,36 +72,6 @@ export default abstract class AbstractInt extends BN implements Codec { assert(super.bitLength() <= bitLength, `${this.toRawType()}: Input too large. Found input with ${super.bitLength()} bits, expected ${bitLength}`); } - /** @internal */ - public static decodeAbstracInt (value: AnyNumber, bitLength: UIntBitLength, isNegative: boolean): string { - // This function returns a string, which will be passed in the BN - // constructor. It would be ideal to actually return a BN, but there's a - // bug: https://github.com/indutny/bn.js/issues/206. - if (isHex(value, -1, true)) { - return hexToBn(value, { isLe: false, isNegative }).toString(); - } else if (isU8a(value)) { - return AbstractInt.decodeAbstracIntU8a(value, bitLength, isNegative); - } else if (isString(value)) { - return new BN(value.toString(), 10).toString(); - } - - return bnToBn(value).toString(); - } - - /** @internal */ - private static decodeAbstracIntU8a (value: Uint8Array, bitLength: UIntBitLength, isNegative: boolean): string { - if (!value.length) { - return '0'; - } - - try { - // NOTE When passing u8a in (typically from decoded data), it is always Little Endian - return u8aToBn(value.subarray(0, bitLength / 8), { isLe: true, isNegative }).toString(); - } catch (error) { - throw new Error(`AbstractInt: failed on ${JSON.stringify(value)}:: ${error.message}`); - } - } - /** * @description The length of the value when encoded as a Uint8Array */ diff --git a/packages/types/src/codec/StructAny.ts b/packages/types/src/codec/StructAny.ts index ec7ae30726..efb0eecc45 100644 --- a/packages/types/src/codec/StructAny.ts +++ b/packages/types/src/codec/StructAny.ts @@ -12,6 +12,11 @@ import Raw from './Raw'; import { compareMap } from './utils'; +/** @internal */ +function decodeJson (value?: { [index: string]: any } | null): [string, any][] { + return Object.entries(value || {}); +} + /** * @name Json * @description @@ -24,7 +29,7 @@ export default class StructAny extends Map implements Codec { public readonly registry: Registry; constructor (registry: Registry, value?: { [index: string]: any } | null) { - const decoded = StructAny.decodeJson(value); + const decoded = decodeJson(value); super(decoded); @@ -44,11 +49,6 @@ export default class StructAny extends Map implements Codec { }); } - /** @internal */ - private static decodeJson (value?: { [index: string]: any } | null): [string, any][] { - return Object.entries(value || {}); - } - /** * @description Always 0, never encodes as a Uint8Array */ diff --git a/packages/types/src/codec/Tuple.ts b/packages/types/src/codec/Tuple.ts index 0c4c9a4477..079e1a21f4 100644 --- a/packages/types/src/codec/Tuple.ts +++ b/packages/types/src/codec/Tuple.ts @@ -17,6 +17,29 @@ type TupleTypes = (Constructor | keyof InterfaceTypes)[] | { [index: string]: Constructor | keyof InterfaceTypes; }; +/** @internal */ +function decodeTuple (registry: Registry, _Types: TupleConstructors, value: AnyU8a | string | (AnyU8a | AnyNumber | AnyString | undefined | null)[]): Codec[] { + if (isU8a(value)) { + return decodeU8a(registry, value, _Types); + } else if (isHex(value)) { + return decodeTuple(registry, _Types, hexToU8a(value)); + } + + const Types: Constructor[] = Array.isArray(_Types) + ? _Types + : Object.values(_Types); + + return Types.map((Type, index): Codec => { + try { + if (value?.[index] instanceof Type) return value[index] as any; + + return new Type(registry, value?.[index]); + } catch (error) { + throw new Error(`Tuple: failed on ${index}:: ${error.message}`); + } + }); +} + /** * @name Tuple * @description @@ -31,34 +54,11 @@ export default class Tuple extends AbstractArray { ? Types.map((type): Constructor => typeToConstructor(registry, type)) : mapToTypeMap(registry, Types); - super(registry, ...Tuple.decodeTuple(registry, Clazzes, value)); + super(registry, ...decodeTuple(registry, Clazzes, value)); this._Types = Clazzes; } - /** @internal */ - private static decodeTuple (registry: Registry, _Types: TupleConstructors, value: AnyU8a | string | (AnyU8a | AnyNumber | AnyString | undefined | null)[]): Codec[] { - if (isU8a(value)) { - return decodeU8a(registry, value, _Types); - } else if (isHex(value)) { - return Tuple.decodeTuple(registry, _Types, hexToU8a(value)); - } - - const Types: Constructor[] = Array.isArray(_Types) - ? _Types - : Object.values(_Types); - - return Types.map((Type, index): Codec => { - try { - if (value?.[index] instanceof Type) return value[index] as any; - - return new Type(registry, value?.[index]); - } catch (error) { - throw new Error(`Tuple: failed on ${index}:: ${error.message}`); - } - }); - } - public static with (Types: TupleTypes): Constructor { return class extends Tuple { constructor (registry: Registry, value?: any) { diff --git a/packages/types/src/codec/U8aFixed.ts b/packages/types/src/codec/U8aFixed.ts index 6423a8408e..2431ca5900 100644 --- a/packages/types/src/codec/U8aFixed.ts +++ b/packages/types/src/codec/U8aFixed.ts @@ -13,6 +13,28 @@ import Raw from './Raw'; // as a result of the Polkadot claims module. (Technically we don't need the 520 in here) export type BitLength = 8 | 16 | 32 | 64 | 128 | 160 | 256 | 512 | 520 | 1024 | 2048; +/** @internal */ +function decodeU8aFixed (value: AnyU8a, bitLength: BitLength): AnyU8a { + if (Array.isArray(value) || isString(value)) { + return decodeU8aFixed(u8aToU8a(value), bitLength); + } + + // ensure that we have an actual u8a with the full length as specified by + // the bitLength input (padded with zeros as required) + const byteLength = bitLength / 8; + const sub = value.subarray(0, byteLength); + + if (sub.length === byteLength) { + return sub; + } + + const u8a = new Uint8Array(byteLength); + + u8a.set(sub, 0); + + return u8a; +} + /** * @name U8aFixed * @description @@ -21,29 +43,7 @@ export type BitLength = 8 | 16 | 32 | 64 | 128 | 160 | 256 | 512 | 520 | 1024 | */ export default class U8aFixed extends Raw { constructor (registry: Registry, value: AnyU8a = new Uint8Array(), bitLength: BitLength = 256) { - super(registry, U8aFixed.decodeU8aFixed(value, bitLength)); - } - - /** @internal */ - private static decodeU8aFixed (value: AnyU8a, bitLength: BitLength): AnyU8a { - if (Array.isArray(value) || isString(value)) { - return U8aFixed.decodeU8aFixed(u8aToU8a(value), bitLength); - } - - // ensure that we have an actual u8a with the full length as specified by - // the bitLength input (padded with zeros as required) - const byteLength = bitLength / 8; - const sub = value.subarray(0, byteLength); - - if (sub.length === byteLength) { - return sub; - } - - const u8a = new Uint8Array(byteLength); - - u8a.set(sub, 0); - - return u8a; + super(registry, decodeU8aFixed(value, bitLength)); } public static with (bitLength: BitLength, typeName?: string): Constructor { diff --git a/packages/types/src/create/registry.ts b/packages/types/src/create/registry.ts index 800f2d866f..b72a5e7200 100644 --- a/packages/types/src/create/registry.ts +++ b/packages/types/src/create/registry.ts @@ -270,11 +270,11 @@ export class TypeRegistry implements Registry { this.#classes.set(arg1, arg2); } else { - this.registerObject(arg1); + this._registerObject(arg1); } } - private registerObject (obj: RegistryTypes): void { + private _registerObject (obj: RegistryTypes): void { Object.entries(obj).forEach(([name, type]): void => { if (isFunction(type)) { // This _looks_ a bit funny, but `typeof Clazz === 'function' diff --git a/packages/types/src/extrinsic/Extrinsic.ts b/packages/types/src/extrinsic/Extrinsic.ts index 5044713ce4..bc839bf73b 100644 --- a/packages/types/src/extrinsic/Extrinsic.ts +++ b/packages/types/src/extrinsic/Extrinsic.ts @@ -173,11 +173,11 @@ abstract class ExtrinsicBase extends Base { */ export default class Extrinsic extends ExtrinsicBase implements IExtrinsic { constructor (registry: Registry, value: Extrinsic | ExtrinsicValue | AnyU8a | Call | undefined, { version }: CreateOptions = {}) { - super(registry, Extrinsic.decodeExtrinsic(registry, value, version)); + super(registry, Extrinsic._decodeExtrinsic(registry, value, version)); } /** @internal */ - private static newFromValue (registry: Registry, value: any, version: number): ExtrinsicVx | ExtrinsicUnknown { + private static _newFromValue (registry: Registry, value: any, version: number): ExtrinsicVx | ExtrinsicUnknown { if (value instanceof Extrinsic) { return value._raw; } @@ -191,20 +191,20 @@ export default class Extrinsic extends ExtrinsicBase implements IExtrinsic { } /** @internal */ - public static decodeExtrinsic (registry: Registry, value: Extrinsic | ExtrinsicValue | AnyU8a | Call | undefined, version: number = DEFAULT_VERSION): ExtrinsicVx | ExtrinsicUnknown { + private static _decodeExtrinsic (registry: Registry, value: Extrinsic | ExtrinsicValue | AnyU8a | Call | undefined, version: number = DEFAULT_VERSION): ExtrinsicVx | ExtrinsicUnknown { if (isU8a(value) || Array.isArray(value) || isHex(value)) { - return Extrinsic.decodeU8a(registry, u8aToU8a(value), version); + return Extrinsic._decodeU8a(registry, u8aToU8a(value), version); } else if (value instanceof registry.createClass('Call')) { - return Extrinsic.newFromValue(registry, { method: value }, version); + return Extrinsic._newFromValue(registry, { method: value }, version); } - return Extrinsic.newFromValue(registry, value, version); + return Extrinsic._newFromValue(registry, value, version); } /** @internal */ - private static decodeU8a (registry: Registry, value: Uint8Array, version: number): ExtrinsicVx | ExtrinsicUnknown { + private static _decodeU8a (registry: Registry, value: Uint8Array, version: number): ExtrinsicVx | ExtrinsicUnknown { if (!value.length) { - return Extrinsic.newFromValue(registry, new Uint8Array(), version); + return Extrinsic._newFromValue(registry, new Uint8Array(), version); } const [offset, length] = Compact.decodeU8a(value); @@ -214,7 +214,7 @@ export default class Extrinsic extends ExtrinsicBase implements IExtrinsic { const data = value.subarray(offset, total); - return Extrinsic.newFromValue(registry, data.subarray(1), data[0]); + return Extrinsic._newFromValue(registry, data.subarray(1), data[0]); } /** diff --git a/packages/types/src/extrinsic/ExtrinsicEra.ts b/packages/types/src/extrinsic/ExtrinsicEra.ts index 364eee63b9..7ad597fb10 100644 --- a/packages/types/src/extrinsic/ExtrinsicEra.ts +++ b/packages/types/src/extrinsic/ExtrinsicEra.ts @@ -28,6 +28,17 @@ interface ImmortalEnumDef { ImmortalEra: string; } +function getTrailingZeros (period: number): number { + const binary = period.toString(2); + let index = 0; + + while (binary[binary.length - 1 - index] === '0') { + index++; + } + + return index; +} + /** * @name ImmortalEra * @description @@ -52,19 +63,19 @@ export class MortalEra extends Tuple { super(registry, { period: U64, phase: U64 - }, MortalEra.decodeMortalEra(registry, value)); + }, MortalEra._decodeMortalEra(registry, value)); } /** @internal */ - private static decodeMortalEra (registry: Registry, value?: MortalMethod | Uint8Array | number[] | string): MortalEraValue { + private static _decodeMortalEra (registry: Registry, value?: MortalMethod | Uint8Array | number[] | string): MortalEraValue { if (isHex(value)) { - return MortalEra.decodeMortalU8a(registry, hexToU8a(value)); + return MortalEra._decodeMortalU8a(registry, hexToU8a(value)); } else if (Array.isArray(value)) { - return MortalEra.decodeMortalU8a(registry, new Uint8Array(value)); + return MortalEra._decodeMortalU8a(registry, new Uint8Array(value)); } else if (isU8a(value)) { - return MortalEra.decodeMortalU8a(registry, value); + return MortalEra._decodeMortalU8a(registry, value); } else if (isObject(value)) { - return MortalEra.decodeMortalObject(registry, value); + return MortalEra._decodeMortalObject(registry, value); } else if (!value) { return [new U64(registry), new U64(registry)]; } @@ -73,7 +84,7 @@ export class MortalEra extends Tuple { } /** @internal */ - private static decodeMortalObject (registry: Registry, value: MortalMethod): MortalEraValue { + private static _decodeMortalObject (registry: Registry, value: MortalMethod): MortalEraValue { const { current, period } = value; let calPeriod = Math.pow(2, Math.ceil(Math.log2(period))); @@ -87,7 +98,7 @@ export class MortalEra extends Tuple { } /** @internal */ - private static decodeMortalU8a (registry: Registry, value: Uint8Array): MortalEraValue { + private static _decodeMortalU8a (registry: Registry, value: Uint8Array): MortalEraValue { if (value.length === 0) { return [new U64(registry), new U64(registry)]; } @@ -157,7 +168,7 @@ export class MortalEra extends Tuple { const period = this.period.toNumber(); const phase = this.phase.toNumber(); const quantizeFactor = Math.max(period >> 12, 1); - const trailingZeros = this.getTrailingZeros(period); + const trailingZeros = getTrailingZeros(period); const encoded = Math.min(15, Math.max(1, trailingZeros - 1)) + (((phase / quantizeFactor) << 4)); const first = encoded >> 8; const second = encoded & 0xff; @@ -184,20 +195,6 @@ export class MortalEra extends Tuple { // FIXME No toNumber() here return this.birth(current) + this.period.toNumber(); } - - /** - * @description convert the number to binary and get the trailing zero's. - */ - private getTrailingZeros (period: number): number { - const binary = period.toString(2); - let index = 0; - - while (binary[binary.length - 1 - index] === '0') { - index++; - } - - return index; - } } /** @@ -210,16 +207,16 @@ export default class ExtrinsicEra extends Enum implements IExtrinsicEra { super(registry, { ImmortalEra, MortalEra - }, ExtrinsicEra.decodeExtrinsicEra(value)); + }, ExtrinsicEra._decodeExtrinsicEra(value)); } /** @internal */ // eslint-disable-next-line @typescript-eslint/ban-types - private static decodeExtrinsicEra (value: IExtrinsicEra | MortalMethod | MortalEnumDef | ImmortalEnumDef | Uint8Array | string = new Uint8Array()): Uint8Array | Object | undefined { + private static _decodeExtrinsicEra (value: IExtrinsicEra | MortalMethod | MortalEnumDef | ImmortalEnumDef | Uint8Array | string = new Uint8Array()): Uint8Array | Object | undefined { if (value instanceof ExtrinsicEra) { - return ExtrinsicEra.decodeExtrinsicEra(value.toU8a()); + return ExtrinsicEra._decodeExtrinsicEra(value.toU8a()); } else if (isHex(value)) { - return ExtrinsicEra.decodeExtrinsicEra(hexToU8a(value)); + return ExtrinsicEra._decodeExtrinsicEra(hexToU8a(value)); } else if (!value || isU8a(value)) { return (!value?.length || value[0] === 0) ? new Uint8Array([0]) diff --git a/packages/types/src/extrinsic/v1/ExtrinsicSignature.ts b/packages/types/src/extrinsic/v1/ExtrinsicSignature.ts index e78da29d4a..82e85a582f 100644 --- a/packages/types/src/extrinsic/v1/ExtrinsicSignature.ts +++ b/packages/types/src/extrinsic/v1/ExtrinsicSignature.ts @@ -99,7 +99,7 @@ export default class ExtrinsicSignatureV1 extends Struct implements IExtrinsicSi return this.registry.createType('Compact', 0); } - private injectSignature (signer: Address, signature: Signature, { era, nonce }: ExtrinsicPayloadV1): IExtrinsicSignature { + private _injectSignature (signer: Address, signature: Signature, { era, nonce }: ExtrinsicPayloadV1): IExtrinsicSignature { this.set('era', era); this.set('nonce', nonce); this.set('signer', signer); @@ -112,7 +112,7 @@ export default class ExtrinsicSignatureV1 extends Struct implements IExtrinsicSi * @description Adds a raw signature */ public addSignature (signer: Address | Uint8Array | string, signature: Uint8Array | string, payload: ExtrinsicPayloadValue | Uint8Array | string): IExtrinsicSignature { - return this.injectSignature( + return this._injectSignature( this.registry.createType('Address', signer), this.registry.createType('Signature', signature), new ExtrinsicPayloadV1(this.registry, payload) @@ -142,7 +142,7 @@ export default class ExtrinsicSignatureV1 extends Struct implements IExtrinsicSi const payload = this.createPayload(method, options); const signature = this.registry.createType('Signature', payload.sign(account)); - return this.injectSignature(signer, signature, payload); + return this._injectSignature(signer, signature, payload); } /** @@ -153,7 +153,7 @@ export default class ExtrinsicSignatureV1 extends Struct implements IExtrinsicSi const payload = this.createPayload(method, options); const signature = this.registry.createType('Signature', new Uint8Array(64).fill(0x42)); - return this.injectSignature(signer, signature, payload); + return this._injectSignature(signer, signature, payload); } /** diff --git a/packages/types/src/generic/Address.ts b/packages/types/src/generic/Address.ts index 93759a11c7..2d59289f68 100644 --- a/packages/types/src/generic/Address.ts +++ b/packages/types/src/generic/Address.ts @@ -50,11 +50,11 @@ function decodeU8a (registry: Registry, value: Uint8Array): AccountId | AccountI */ export default class Address extends Base { constructor (registry: Registry, value: AnyAddress = new Uint8Array()) { - super(registry, Address.decodeAddress(registry, value)); + super(registry, Address._decodeAddress(registry, value)); } /** @internal */ - private static decodeAddress (registry: Registry, value: AnyAddress): AccountId | AccountIndex { + private static _decodeAddress (registry: Registry, value: AnyAddress): AccountId | AccountIndex { if (value instanceof AccountId || value instanceof AccountIndex) { return value; } else if (value instanceof Address) { diff --git a/packages/types/src/generic/ConsensusEngineId.ts b/packages/types/src/generic/ConsensusEngineId.ts index 30a3585c7b..efe9bb8656 100644 --- a/packages/types/src/generic/ConsensusEngineId.ts +++ b/packages/types/src/generic/ConsensusEngineId.ts @@ -57,7 +57,7 @@ export default class ConsensusEngineId extends U32 { return this.eq(CID_GRPA); } - private getAuraAuthor (bytes: Bytes, sessionValidators: AccountId[]): AccountId { + private _getAuraAuthor (bytes: Bytes, sessionValidators: AccountId[]): AccountId { return sessionValidators[ this.registry.createType('RawAuraPreDigest', bytes.toU8a(true)) .slotNumber @@ -66,7 +66,7 @@ export default class ConsensusEngineId extends U32 { ]; } - private getBabeAuthor (bytes: Bytes, sessionValidators: AccountId[]): AccountId { + private _getBabeAuthor (bytes: Bytes, sessionValidators: AccountId[]): AccountId { const digest = this.registry.createType('RawBabePreDigestCompat', bytes.toU8a(true)); return sessionValidators[ @@ -80,9 +80,9 @@ export default class ConsensusEngineId extends U32 { public extractAuthor (bytes: Bytes, sessionValidators: AccountId[]): AccountId | undefined { if (sessionValidators?.length) { if (this.isAura) { - return this.getAuraAuthor(bytes, sessionValidators); + return this._getAuraAuthor(bytes, sessionValidators); } else if (this.isBabe) { - return this.getBabeAuthor(bytes, sessionValidators); + return this._getBabeAuthor(bytes, sessionValidators); } }