@polkadot/types-codec 6.12.2-10

package/utils/sanitize.d.ts

@@ -0,0 +1,16 @@
+interface SanitizeOptions {
+    allowNamespaces?: boolean;
+}
+declare type Mapper = (value: string, options?: SanitizeOptions) => string;
+export declare function findClosing(value: string, start: number): number;
+export declare function alias(src: string, dest: string, withChecks?: boolean): Mapper;
+export declare function cleanupCompact(): Mapper;
+export declare function flattenSingleTuple(): Mapper;
+export declare function removeExtensions(type: string, isSized: boolean): Mapper;
+export declare function removeColons(): Mapper;
+export declare function removeGenerics(): Mapper;
+export declare function removePairOf(): Mapper;
+export declare function removeTraits(): Mapper;
+export declare function removeWrap(check: string): Mapper;
+export declare function sanitize(value: String | string, options?: SanitizeOptions): string;
+export {};

package/utils/sanitize.js

@@ -0,0 +1,215 @@
+// Copyright 2017-2021 @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', 'Option', 'UInt', '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()]; // 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() {
+  return value => {
+    for (let index = 0; index < value.length; index++) {
+      if (value[index] === '<') {
+        const end = findClosing(value, index + 1) - 14;
+
+        if (value.substr(end, 14) === ' as HasCompact') {
+          value = `Compact<${value.substr(index + 1, end - index - 1)}>`;
+        }
+      }
+    }
+
+    return value;
+  };
+}
+export function flattenSingleTuple() {
+  const from1 = /,\)/g;
+  const from2 = /\(([^,]+)\)/;
+  return value => {
+    from1.lastIndex = 0;
+    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.substr(0, index)}${replacer(value.substr(start, end - start))}${value.substr(end + 1)}`;
+  }
+} // remove the Bounded* or Weak* wrappers
+
+
+export function removeExtensions(type, isSized) {
+  return value => BOUNDED.reduce((value, tag) => replaceTagWith(value, `${type}${tag}<`, inner => {
+    const parts = inner.split(',').map(s => s.trim()).filter(s => s);
+
+    if (isSized) {
+      parts.pop();
+    }
+
+    return `${tag}<${parts.join(',')}>`;
+  }), value);
+}
+export function removeColons() {
+  return (value, {
+    allowNamespaces
+  } = {}) => {
+    let index = 0;
+
+    while (index !== -1) {
+      index = value.indexOf('::');
+
+      if (index === 0) {
+        value = value.substr(2);
+      } else if (index !== -1) {
+        if (allowNamespaces) {
+          return value;
+        }
+
+        let start = index;
+
+        while (start !== -1 && !BOX_PRECEDING.includes(value[start])) {
+          start--;
+        }
+
+        value = `${value.substr(0, start + 1)}${value.substr(index + 2)}`;
+      }
+    }
+
+    return value;
+  };
+}
+export function removeGenerics() {
+  return value => {
+    for (let index = 0; index < value.length; index++) {
+      if (value[index] === '<') {
+        // check against the allowed wrappers, be it Vec<..>, Option<...> ...
+        const box = ALLOWED_BOXES.find(box => {
+          const start = index - box.length;
+          return start >= 0 && value.substr(start, box.length) === 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
+
+        if (!box) {
+          const end = findClosing(value, index + 1);
+          value = `${value.substr(0, index)}${value.substr(end + 1)}`;
+        }
+      }
+    }
+
+    return value;
+  };
+} // remove the PairOf wrappers
+
+export function removePairOf() {
+  const replacer = inner => `(${inner},${inner})`;
+
+  return value => replaceTagWith(value, 'PairOf<', replacer);
+} // remove the type traits
+
+export function removeTraits() {
+  const from1 = /\s/g;
+  const from2 = /(T|Self)::/g;
+  const from3 = /<(T|Self)asTrait>::/g;
+  const from4 = /<Tas[a-z]+::Trait>::/g;
+  const from5 = /<LookupasStaticLookup>/g;
+  const from6 = /::Type/g;
+  return value => {
+    from1.lastIndex = 0;
+    from2.lastIndex = 0;
+    from3.lastIndex = 0;
+    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`
+    .replace(from6, '');
+  };
+} // remove wrapping values, i.e. Box<Proposal> -> Proposal
+
+export function removeWrap(check) {
+  const replacer = inner => inner;
+
+  return value => replaceTagWith(value, check, replacer);
+}
+const sanitizeMap = new Map(); // eslint-disable-next-line @typescript-eslint/ban-types
+
+export function sanitize(value, options) {
+  let result = value.toString();
+
+  if (!options) {
+    const memoized = sanitizeMap.get(result);
+
+    if (memoized) {
+      return memoized;
+    }
+  }
+
+  for (let i = 0; i < mappings.length; i++) {
+    result = mappings[i](result, options);
+  }
+
+  result = result.trim();
+
+  if (!options) {
+    sanitizeMap.set(value.toString(), result);
+  }
+
+  return result;
+}

package/utils/sortValues.cjs

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sortAsc = sortAsc;
+exports.sortMap = sortMap;
+exports.sortSet = sortSet;
+
+var _util = require("@polkadot/util");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/** @internal **/
+function isArrayLike(arg) {
+  return arg instanceof Uint8Array || Array.isArray(arg);
+}
+/** @internal **/
+
+
+function isCodec(arg) {
+  return (0, _util.isFunction)(arg && arg.toU8a);
+}
+/** @internal **/
+
+
+function isEnum(arg) {
+  return isCodec(arg) && (0, _util.isNumber)(arg.index) && isCodec(arg.value);
+}
+/** @internal */
+
+
+function isNumberLike(arg) {
+  return (0, _util.isNumber)(arg) || (0, _util.isBn)(arg) || (0, _util.isBigInt)(arg);
+}
+/** @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)
+*/
+
+
+function sortAsc(a, b) {
+  if (isNumberLike(a) && isNumberLike(b)) {
+    return (0, _util.bnToBn)(a).cmp((0, _util.bnToBn)(b));
+  } else if (a instanceof Map && b instanceof Map) {
+    return sortAsc(Array.from(a.values()), Array.from(b.values()));
+  } else if (isEnum(a) && isEnum(b)) {
+    return sortAsc(a.index, b.index) || sortAsc(a.value, b.value);
+  } else if (isArrayLike(a) && isArrayLike(b)) {
+    return sortArray(a, b);
+  } else if (isCodec(a) && isCodec(b)) {
+    // Text, Bool etc.
+    return sortAsc(a.toU8a(true), b.toU8a(true));
+  }
+
+  throw new Error(`Attempting to sort unrecognized values: ${(0, _util.stringify)(a)} (typeof ${typeof a}) <-> ${(0, _util.stringify)(b)} (typeof ${typeof b})`);
+}
+
+function sortSet(set) {
+  return new Set(Array.from(set).sort(sortAsc));
+}
+
+function sortMap(map) {
+  return new Map(Array.from(map.entries()).sort((_ref, _ref2) => {
+    let [keyA] = _ref;
+    let [keyB] = _ref2;
+    return sortAsc(keyA, keyB);
+  }));
+}

package/utils/sortValues.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="bn.js" />
+import type { BN } from '@polkadot/util';
+import type { Codec } from '../types';
+declare type SortArg = Codec | Codec[] | number[] | BN | bigint | number | Uint8Array;
+/**
+* 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 declare function sortAsc<V extends SortArg = Codec>(a: V, b: V): number;
+export declare function sortSet<V extends Codec = Codec>(set: Set<V>): Set<V>;
+export declare function sortMap<K extends Codec = Codec, V extends Codec = Codec>(map: Map<K, V>): Map<K, V>;
+export {};

package/utils/sortValues.js

@@ -0,0 +1,73 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { bnToBn, isBigInt, isBn, isFunction, isNumber, stringify } from '@polkadot/util';
+
+/** @internal **/
+function isArrayLike(arg) {
+  return arg instanceof Uint8Array || Array.isArray(arg);
+}
+/** @internal **/
+
+
+function isCodec(arg) {
+  return isFunction(arg && arg.toU8a);
+}
+/** @internal **/
+
+
+function isEnum(arg) {
+  return isCodec(arg) && isNumber(arg.index) && isCodec(arg.value);
+}
+/** @internal */
+
+
+function isNumberLike(arg) {
+  return isNumber(arg) || isBn(arg) || isBigInt(arg);
+}
+/** @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));
+  } else if (a instanceof Map && b instanceof Map) {
+    return sortAsc(Array.from(a.values()), Array.from(b.values()));
+  } else if (isEnum(a) && isEnum(b)) {
+    return sortAsc(a.index, b.index) || sortAsc(a.value, b.value);
+  } else if (isArrayLike(a) && isArrayLike(b)) {
+    return sortArray(a, b);
+  } else if (isCodec(a) && isCodec(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) {
+  return new Set(Array.from(set).sort(sortAsc));
+}
+export function sortMap(map) {
+  return new Map(Array.from(map.entries()).sort(([keyA], [keyB]) => sortAsc(keyA, keyB)));
+}

package/utils/typeToConstructor.cjs

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.typeToConstructor = typeToConstructor;
+
+var _util = require("@polkadot/util");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+function typeToConstructor(registry, type) {
+  return (0, _util.isString)(type) ? registry.createClassUnsafe(type) : type;
+}

package/utils/typeToConstructor.d.ts

@@ -0,0 +1,2 @@
+import type { Codec, CodecClass, CodecRegistry } from '../types';
+export declare function typeToConstructor<T extends Codec = Codec>(registry: CodecRegistry, type: string | CodecClass<T>): CodecClass<T>;

package/utils/typeToConstructor.js

@@ -0,0 +1,6 @@
+// Copyright 2017-2021 @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.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.typesToMap = typesToMap;
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+function typesToMap(registry, Types) {
+  const entries = Object.entries(Types);
+  const result = {};
+
+  for (let i = 0; i < entries.length; i++) {
+    const [key, Type] = entries[i];
+    result[key] = registry.getClassName(Type) || new Type(registry).toRawType();
+  }
+
+  return result;
+}

package/utils/typesToMap.d.ts

@@ -0,0 +1,2 @@
+import type { CodecClass, CodecRegistry } from '../types';
+export declare function typesToMap(registry: CodecRegistry, Types: Record<string, CodecClass>): Record<string, string>;

package/utils/typesToMap.js

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

package/utils/util.cjs

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasEq = hasEq;
+
+var _util = require("@polkadot/util");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+function hasEq(o) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  return (0, _util.isFunction)(o.eq);
+}

package/utils/util.d.ts

@@ -0,0 +1,3 @@
+export declare function hasEq(o: unknown): o is {
+    eq: (other: unknown) => boolean;
+};

package/utils/util.js

@@ -0,0 +1,7 @@
+// Copyright 2017-2021 @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
+  return isFunction(o.eq);
+}