@polkadot/types-codec 9.5.1 → 9.6.1

package/utils/mapToTypeMap.js

@@ -1,19 +1,18 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { typeToConstructor } from "./typeToConstructor.js";
+
 /**
  * @description takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
  */
-
 export function mapToTypeMap(registry, input) {
   const entries = Object.entries(input);
   const count = entries.length;
   const output = [new Array(count), new Array(count)];
-
   for (let i = 0; i < count; i++) {
     output[1][i] = entries[i][0];
     output[0][i] = typeToConstructor(registry, entries[i][1]);
   }
-
   return output;
 }

package/utils/sanitize.js

@@ -1,56 +1,70 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 const BOUNDED = ['BTreeMap', 'BTreeSet', 'HashMap', 'Vec'];
 const ALLOWED_BOXES = BOUNDED.concat(['Compact', 'DoNotConstruct', 'Int', 'Linkage', 'Range', 'RangeInclusive', 'Result', 'Opaque', 'Option', 'UInt', 'WrapperKeepOpaque', 'WrapperOpaque']);
 const BOX_PRECEDING = ['<', '(', '[', '"', ',', ' ']; // start of vec, tuple, fixed array, part of struct def or in tuple
 
-const mappings = [// alias <T::InherentOfflineReport as InherentOfflineReport>::Inherent -> InherentOfflineReport
-alias('<T::InherentOfflineReport as InherentOfflineReport>::Inherent', 'InherentOfflineReport', false), alias('VecDeque<', 'Vec<', false), // <T::Balance as HasCompact>
-cleanupCompact(), // Change BoundedVec<Type, Size> to Vec<Type>
-removeExtensions('Bounded', true), // Change WeakVec<Type> to Vec<Type>
-removeExtensions('Weak', false), // Remove all the trait prefixes
-removeTraits(), // remove PairOf<T> -> (T, T)
-removePairOf(), // remove boxing, `Box<Proposal>` -> `Proposal`
-removeWrap('Box<'), // remove generics, `MisbehaviorReport<Hash, BlockNumber>` -> `MisbehaviorReport`
-removeGenerics(), // alias String -> Text (compat with jsonrpc methods)
-alias('String', 'Text'), // alias Vec<u8> -> Bytes
-alias('Vec<u8>', 'Bytes'), alias('&\\[u8\\]', 'Bytes'), alias("&'static\\[u8\\]", 'Bytes'), // alias RawAddress -> Address
-alias('RawAddress', 'Address'), // lookups, mapped to Address/AccountId as appropriate in runtime
-alias('Lookup::Source', 'LookupSource'), alias('Lookup::Target', 'LookupTarget'), // HACK duplication between contracts & primitives, however contracts prefixed with exec
-alias('exec::StorageKey', 'ContractStorageKey'), // flattens tuples with one value, `(AccountId)` -> `AccountId`
-flattenSingleTuple(), // converts ::Type to Type, <T as Trait<I>>::Proposal -> Proposal
-removeColons(), // remove all trailing spaces - this should always be the last
-trim()]; // given a string, trim it
-
+const mappings = [
+// alias <T::InherentOfflineReport as InherentOfflineReport>::Inherent -> InherentOfflineReport
+alias('<T::InherentOfflineReport as InherentOfflineReport>::Inherent', 'InherentOfflineReport', false), alias('VecDeque<', 'Vec<', false),
+// <T::Balance as HasCompact>
+cleanupCompact(),
+// Change BoundedVec<Type, Size> to Vec<Type>
+removeExtensions('Bounded', true),
+// Change WeakVec<Type> to Vec<Type>
+removeExtensions('Weak', false),
+// Remove all the trait prefixes
+removeTraits(),
+// remove PairOf<T> -> (T, T)
+removePairOf(),
+// remove boxing, `Box<Proposal>` -> `Proposal`
+removeWrap('Box<'),
+// remove generics, `MisbehaviorReport<Hash, BlockNumber>` -> `MisbehaviorReport`
+removeGenerics(),
+// alias String -> Text (compat with jsonrpc methods)
+alias('String', 'Text'),
+// alias Vec<u8> -> Bytes
+alias('Vec<u8>', 'Bytes'), alias('&\\[u8\\]', 'Bytes'), alias("&'static\\[u8\\]", 'Bytes'),
+// alias RawAddress -> Address
+alias('RawAddress', 'Address'),
+// lookups, mapped to Address/AccountId as appropriate in runtime
+alias('Lookup::Source', 'LookupSource'), alias('Lookup::Target', 'LookupTarget'),
+// HACK duplication between contracts & primitives, however contracts prefixed with exec
+alias('exec::StorageKey', 'ContractStorageKey'),
+// flattens tuples with one value, `(AccountId)` -> `AccountId`
+flattenSingleTuple(),
+// converts ::Type to Type, <T as Trait<I>>::Proposal -> Proposal
+removeColons(),
+// remove all trailing spaces - this should always be the last
+trim()];
+
+// given a string, trim it
 export function trim() {
   return value => value.trim();
-} // given a starting index, find the closing >
+}
 
+// given a starting index, find the closing >
 export function findClosing(value, start) {
   let depth = 0;
-
   for (let index = start; index < value.length; index++) {
     if (value[index] === '>') {
       if (!depth) {
         return index;
       }
-
       depth--;
     } else if (value[index] === '<') {
       depth++;
     }
   }
-
   throw new Error(`Unable to find closing matching <> on '${value}' (start ${start})`);
 }
 export function alias(src, dest, withChecks = true) {
   const from = new RegExp(`(^${src}|${BOX_PRECEDING.map(box => `\\${box}${src}`).join('|')})`, 'g');
-
   const to = src => {
     from.lastIndex = 0;
     return withChecks && BOX_PRECEDING.includes(src[0]) ? `${src[0]}${dest}` : dest;
   };
-
   return value => value.replace(from, to);
 }
 export function cleanupCompact() {
@@ -59,14 +73,12 @@ export function cleanupCompact() {
       for (let index = 0; index < value.length; index++) {
         if (value[index] === '<') {
           const end = findClosing(value, index + 1) - 14;
-
           if (value.substring(end, end + 14) === ' as HasCompact') {
             value = `Compact<${value.substring(index + 1, end)}>`;
           }
         }
       }
     }
-
     return value;
   };
 }
@@ -75,67 +87,57 @@ export function flattenSingleTuple() {
   const from2 = /\(([^,]+)\)/;
   return value => {
     from1.lastIndex = 0;
-    return value // tuples may have trailing commas, e.g. (u32, BlockNumber, )
-    .replace(from1, ')') // change (u32) -> u32
+    return value
+    // tuples may have trailing commas, e.g. (u32, BlockNumber, )
+    .replace(from1, ')')
+    // change (u32) -> u32
     .replace(from2, '$1');
   };
 }
-
 function replaceTagWith(value, matcher, replacer) {
   let index = -1;
-
   while (true) {
     index = value.indexOf(matcher, index + 1);
-
     if (index === -1) {
       return value;
     }
-
     const start = index + matcher.length;
     const end = findClosing(value, start);
     value = `${value.substring(0, index)}${replacer(value.substring(start, end))}${value.substring(end + 1)}`;
   }
-} // remove the Bounded* or Weak* wrappers
-
+}
 
+// remove the Bounded* or Weak* wrappers
 export function removeExtensions(type, isSized) {
   return value => {
     for (let i = 0; i < BOUNDED.length; i++) {
       const tag = BOUNDED[i];
       value = replaceTagWith(value, `${type}${tag}<`, v => {
         const parts = v.split(',').map(s => s.trim()).filter(s => s);
-
         if (isSized) {
           parts.pop();
         }
-
         return `${tag}<${parts.join(',')}>`;
       });
     }
-
     return value;
   };
 }
 export function removeColons() {
   return value => {
     let index = 0;
-
     while (index !== -1) {
       index = value.indexOf('::');
-
       if (index === 0) {
         value = value.substring(2);
       } else if (index !== -1) {
         let start = index;
-
         while (start !== -1 && !BOX_PRECEDING.includes(value[start])) {
           start--;
         }
-
         value = `${value.substring(0, start + 1)}${value.substring(index + 2)}`;
       }
     }
-
     return value;
   };
 }
@@ -146,27 +148,29 @@ export function removeGenerics() {
         // check against the allowed wrappers, be it Vec<..>, Option<...> ...
         const box = ALLOWED_BOXES.find(box => {
           const start = index - box.length;
-          return start >= 0 && value.substring(start, index) === box && ( // make sure it is stand-alone, i.e. don't catch ElectionResult<...> as Result<...>
+          return start >= 0 && value.substring(start, index) === box && (
+          // make sure it is stand-alone, i.e. don't catch ElectionResult<...> as Result<...>
           start === 0 || BOX_PRECEDING.includes(value[start - 1]));
-        }); // we have not found anything, unwrap generic innards
+        });
 
+        // we have not found anything, unwrap generic innards
         if (!box) {
           const end = findClosing(value, index + 1);
           value = `${value.substring(0, index)}${value.substring(end + 1)}`;
         }
       }
     }
-
     return value;
   };
-} // remove the PairOf wrappers
+}
 
+// remove the PairOf wrappers
 export function removePairOf() {
   const replacer = v => `(${v},${v})`;
-
   return value => replaceTagWith(value, 'PairOf<', replacer);
-} // remove the type traits
+}
 
+// remove the type traits
 export function removeTraits() {
   const from1 = /\s/g;
   const from2 = /(T|Self)::/g;
@@ -181,36 +185,38 @@ export function removeTraits() {
     from4.lastIndex = 0;
     from5.lastIndex = 0;
     from6.lastIndex = 0;
-    return value // remove all whitespaces
-    .replace(from1, '') // anything `T::<type>` to end up as `<type>`
-    .replace(from2, '') // replace `<T as Trait>::` (whitespaces were removed above)
-    .replace(from3, '') // replace `<T as something::Trait>::` (whitespaces were removed above)
-    .replace(from4, '') // replace <Lookup as StaticLookup>
-    .replace(from5, 'Lookup') // replace `<...>::Type`
+    return value
+    // remove all whitespaces
+    .replace(from1, '')
+    // anything `T::<type>` to end up as `<type>`
+    .replace(from2, '')
+    // replace `<T as Trait>::` (whitespaces were removed above)
+    .replace(from3, '')
+    // replace `<T as something::Trait>::` (whitespaces were removed above)
+    .replace(from4, '')
+    // replace <Lookup as StaticLookup>
+    .replace(from5, 'Lookup')
+    // replace `<...>::Type`
     .replace(from6, '');
   };
-} // remove wrapping values, i.e. Box<Proposal> -> Proposal
+}
 
+// remove wrapping values, i.e. Box<Proposal> -> Proposal
 export function removeWrap(check) {
   const replacer = v => v;
-
   return value => replaceTagWith(value, check, replacer);
 }
 const sanitizeMap = new Map();
 export function sanitize(value) {
   const startValue = value.toString();
   const memoized = sanitizeMap.get(startValue);
-
   if (memoized) {
     return memoized;
   }
-
   let result = startValue;
-
   for (let i = 0; i < mappings.length; i++) {
     result = mappings[i](result);
   }
-
   sanitizeMap.set(startValue, result);
   return result;
 }

package/utils/sortValues.js

@@ -1,54 +1,46 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { bnToBn, isBigInt, isBn, isFunction, isNumber, stringify } from '@polkadot/util';
 
+import { bnToBn, isBigInt, isBn, isFunction, isNumber, stringify } from '@polkadot/util';
 /** @internal **/
 function isArrayLike(arg) {
   return arg instanceof Uint8Array || Array.isArray(arg);
 }
-/** @internal **/
-
 
+/** @internal **/
 function isCodec(arg) {
   return isFunction(arg && arg.toU8a);
 }
-/** @internal **/
-
 
+/** @internal **/
 function isEnum(arg) {
   return isCodec(arg) && isNumber(arg.index) && isCodec(arg.value);
 }
-/** @internal */
-
 
+/** @internal */
 function isNumberLike(arg) {
   return isNumber(arg) || isBn(arg) || isBigInt(arg);
 }
-/** @internal */
-
 
+/** @internal */
 function sortArray(a, b) {
   // Vec, Tuple, Bytes etc.
   let sortRes = 0;
   const minLen = Math.min(a.length, b.length);
-
   for (let i = 0; i < minLen; ++i) {
     sortRes = sortAsc(a[i], b[i]);
-
     if (sortRes !== 0) {
       return sortRes;
     }
   }
-
   return a.length - b.length;
 }
+
 /**
 * Sort keys/values of BTreeSet/BTreeMap in ascending order for encoding compatibility with Rust's BTreeSet/BTreeMap
 * (https://doc.rust-lang.org/stable/std/collections/struct.BTreeSet.html)
 * (https://doc.rust-lang.org/stable/std/collections/struct.BTreeMap.html)
 */
-
-
 export function sortAsc(a, b) {
   if (isNumberLike(a) && isNumberLike(b)) {
     return bnToBn(a).cmp(bnToBn(b));
@@ -62,7 +54,6 @@ export function sortAsc(a, b) {
     // Text, Bool etc.
     return sortAsc(a.toU8a(true), b.toU8a(true));
   }
-
   throw new Error(`Attempting to sort unrecognized values: ${stringify(a)} (typeof ${typeof a}) <-> ${stringify(b)} (typeof ${typeof b})`);
 }
 export function sortSet(set) {

package/utils/typeToConstructor.js

@@ -1,5 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { isString } from '@polkadot/util';
 export function typeToConstructor(registry, type) {
   return isString(type) ? registry.createClassUnsafe(type) : type;

package/utils/typesToMap.js

@@ -1,11 +1,10 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 export function typesToMap(registry, [Types, keys]) {
   const result = {};
-
   for (let i = 0; i < keys.length; i++) {
     result[keys[i]] = registry.getClassName(Types[i]) || new Types[i](registry).toRawType();
   }
-
   return result;
 }

package/utils/util.js

@@ -1,5 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { isFunction } from '@polkadot/util';
 export function hasEq(o) {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access