All private prefixed with _ (#2157)

* All private prefixed with _

* Fix test

Author: jacogr

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
 

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);

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<TypeDef, never> {
+  private _typeDefIdFields ({ id }: MetaType): Pick<TypeDef, never> {
     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<TypeDef, never> {
+  private _typeDefDefFields (metaType: MetaType, typeIndex?: TypeIndex): Pick<TypeDef, never> {
     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<TypeDef, any> {
+  private _typeDefForEnumVariant (variant: MetaTypeDefEnumVariant): Pick<TypeDef, any> {
     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<TypeDef, never> {
+  private _typeDefForBuiltinPlain (id: string): Pick<TypeDef, never> {
     return {
       info: TypeDefInfo.Plain,
       type: id
     };
   }
 
-  private typeDefForBuiltinTuple (id: TypeIndex[]): Pick<TypeDef, never> {
+  private _typeDefForBuiltinTuple (id: TypeIndex[]): Pick<TypeDef, never> {
     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<TypeDef, never> {
+  private _typeDefForBuiltinVec (id: MetaTypeIdVec, typeIndex?: TypeIndex): Pick<TypeDef, never> {
     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<TypeDef, never> {
+  private _typeDefForBuiltinVecFixed (id: MetaTypeIdVecFixed, typeIndex?: TypeIndex): Pick<TypeDef, never> {
     const { 'array.len': vecLength, 'array.type': vecTypeIndex } = id;
 
     assert(!vecLength || vecLength <= 256, 'MetaRegistry: Only support for [Type; <length>], where length <= 256');
@@ -268,7 +268,7 @@ export default class MetaRegistry extends MetadataRegistryLookup {
     };
   }
 
-  private typeDefForEnum (def: MetaTypeDefEnum, id: MetaTypeIdCustom, typeIndex?: TypeIndex): Pick<TypeDef, any> {
+  private _typeDefForEnum (def: MetaTypeDefEnum, id: MetaTypeIdCustom, typeIndex?: TypeIndex): Pick<TypeDef, any> {
     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<TypeDef, never> {
+  private _typeDefForClikeEnum (def: MetaTypeDefClikeEnum): Pick<TypeDef, never> {
     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<TypeDef, any> {
+  private _typeDefForTupleStruct (def: MetaTypeDefTupleStruct | MetaTypeDefEnumVariantTupleStruct): Pick<TypeDef, any> {
     const tupleStructTypes = (def as MetaTypeDefTupleStruct)['tuple_struct.types'] || (def as MetaTypeDefEnumVariantTupleStruct)['tuple_struct_variant.types'];
     const tupleStructNameIndex = (def as MetaTypeDefEnumVariantTupleStruct)['tuple_struct_variant.name'];
 

packages/api-contract/src/base/Blueprint.ts

@@ -52,13 +52,13 @@ export default class Blueprint<ApiType extends ApiTypes> extends BaseWithTx<ApiT
           return this._apiContracts
             .create(endowment, maxGas, this.codeHash, this.abi.constructors[constructorIndex](...params))
             .signAndSend(account)
-            .pipe(map(this.createResult));
+            .pipe(map(this._createResult));
         }
       )
     };
   }
 
-  private createResult = (result: SubmittableResult): BlueprintCreateResult<ApiType> => {
+  private _createResult = (result: SubmittableResult): BlueprintCreateResult<ApiType> => {
     let contract: Contract<ApiType> | undefined;
 
     if (result.isInBlock) {

packages/api-contract/src/base/Code.ts

@@ -51,12 +51,12 @@ export default class Code<ApiType extends ApiTypes> extends BaseWithTx<ApiType>
           this._apiContracts
             .putCode(maxGas, compactAddLength(this.code))
             .signAndSend(account)
-            .pipe(map(this.createResult))
+            .pipe(map(this._createResult))
       )
     };
   }
 
-  private createResult = (result: ISubmittableResult): CodePutCodeResult<ApiType> => {
+  private _createResult = (result: ISubmittableResult): CodePutCodeResult<ApiType> => {
     let blueprint: Blueprint<ApiType> | undefined;
 
     if (result.isInBlock) {

packages/api-contract/src/base/Contract.ts

@@ -33,6 +33,12 @@ export type ContractCallResult<CallType extends ContractCallTypes> = CallType ex
 export default class Contract<ApiType extends ApiTypes> extends BaseWithTxAndRpcCall<ApiType> {
   public readonly address: Address;
 
+  constructor (api: ApiObject<ApiType>, abi: ContractABIPre | Abi, decorateMethod: DecorateMethod<ApiType>, 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<ApiType, 'rpc'>;
   public call (as: 'tx', message: string, value: BN | number, gasLimit: BN | number, ...params: any[]): ContractCall<ApiType, 'tx'>;
   public call<CallType extends ContractCallTypes> (as: CallType, message: string, value: BN | number, gasLimit: BN | number, ...params: any[]): ContractCall<ApiType, CallType> {
@@ -51,7 +57,7 @@ export default class Contract<ApiType extends ApiTypes> 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<ApiType extends ApiTypes> 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<ApiType extends ApiTypes> extends BaseWithTxAndRpc
       time: Date.now()
     };
   }
-
-  constructor (api: ApiObject<ApiType>, abi: ContractABIPre | Abi, decorateMethod: DecorateMethod<ApiType>, address: string | AccountId | Address) {
-    super(api, abi, decorateMethod);
-
-    this.address = this.registry.createType('Address', address);
-  }
 }

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

packages/api/src/base/Decorate.ts

@@ -184,7 +184,7 @@ export default abstract class Decorate<ApiType extends ApiTypes> 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<ApiType extends ApiTypes> extends Events
     const decorated = (...params: Arg[]): SubmittableExtrinsic<ApiType> =>
       creator(method(...params));
 
-    return this.decorateFunctionMeta(method, decorated as any) as SubmittableExtrinsicFunction<ApiType>;
+    return this._decorateFunctionMeta(method, decorated as any) as SubmittableExtrinsicFunction<ApiType>;
   }
 
   protected _decorateStorage<ApiType extends ApiTypes> (storage: Storage, decorateMethod: DecorateMethod<ApiType>): QueryableStorage<ApiType> {
@@ -321,7 +321,7 @@ export default abstract class Decorate<ApiType extends ApiTypes> 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<Codec> => (
         this.hasSubscriptions
           ? this._rpcCore.state
@@ -348,7 +348,7 @@ export default abstract class Decorate<ApiType extends ApiTypes> 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<u64> =>
       this._rpcCore.state.getStorageSize(getArgs(arg1, arg2)));
@@ -357,11 +357,11 @@ export default abstract class Decorate<ApiType extends ApiTypes> 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<StorageKey[]> =>
-          this.retrieveMapKeys(creator, doubleMapArg)));
+          this._retrieveMapKeys(creator, doubleMapArg)));
     }
 
     // only support multi where subs are available
@@ -372,10 +372,10 @@ export default abstract class Decorate<ApiType extends ApiTypes> extends Events
           args.map((arg: Arg[] | Arg): [StorageEntry, Arg | Arg[]] => [creator, arg])));
     }
 
-    return this.decorateFunctionMeta(creator, decorated) as unknown as QueryableStorageEntry<ApiType>;
+    return this._decorateFunctionMeta(creator, decorated) as unknown as QueryableStorageEntry<ApiType>;
   }
 
-  private decorateStorageRange<ApiType extends ApiTypes> (decorated: QueryableStorageEntry<ApiType>, args: [Arg?, Arg?], range: [Hash, Hash?]): Observable<[Hash, Codec][]> {
+  private _decorateStorageRange<ApiType extends ApiTypes> (decorated: QueryableStorageEntry<ApiType>, 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<ApiType extends ApiTypes> extends Events
       ));
   }
 
-  private decorateStorageLinked<ApiType extends ApiTypes> (creator: StorageEntry, decorateMethod: DecorateMethod<ApiType>): ReturnType<DecorateMethod<ApiType>> {
+  private _decorateStorageLinked<ApiType extends ApiTypes> (creator: StorageEntry, decorateMethod: DecorateMethod<ApiType>): ReturnType<DecorateMethod<ApiType>> {
     const result: Map<Codec, ITuple<[Codec, Linkage<Codec>]> | null> = new Map();
     let subject: BehaviorSubject<LinkageResult>;
     let head: Codec | null = null;
@@ -460,7 +460,7 @@ export default abstract class Decorate<ApiType extends ApiTypes> extends Events
     );
   }
 
-  private retrieveMapKeys ({ iterKey, meta }: StorageEntry, arg?: Arg): Observable<StorageKey[]> {
+  private _retrieveMapKeys ({ iterKey, meta }: StorageEntry, arg?: Arg): Observable<StorageKey[]> {
     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<ApiType extends ApiTypes> 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<Raw>[][]]> =>
         combineLatest([
           of(keys),