@polkadot/types-create 6.12.2-3

package/util/getTypeDef.cjs

@@ -0,0 +1,228 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTypeDef = getTypeDef;
+
+var _typesCodec = require("@polkadot/types-codec");
+
+var _util = require("@polkadot/util");
+
+var _types = require("../types.cjs");
+
+var _typeSplit = require("./typeSplit.cjs");
+
+// Copyright 2017-2021 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+const MAX_NESTED = 64;
+const KNOWN_INTERNALS = ['_alias', '_fallback'];
+
+function getTypeString(typeOrObj) {
+  return (0, _util.isString)(typeOrObj) ? typeOrObj.toString() : JSON.stringify(typeOrObj);
+}
+
+function isRustEnum(details) {
+  const values = Object.values(details);
+
+  if (values.some(v => (0, _util.isNumber)(v))) {
+    (0, _util.assert)(values.every(v => (0, _util.isNumber)(v) && v >= 0 && v <= 255), 'Invalid number-indexed enum definition');
+    return false;
+  }
+
+  return true;
+} // decode an enum of either of the following forms
+//  { _enum: ['A', 'B', 'C'] }
+//  { _enum: { A: AccountId, B: Balance, C: u32 } }
+//  { _enum: { A: 1, B: 2 } }
+
+
+function _decodeEnum(value, details, count) {
+  value.info = _types.TypeDefInfo.Enum; // not as pretty, but remain compatible with oo7 for both struct and Array types
+
+  if (Array.isArray(details)) {
+    value.sub = details.map((name, index) => ({
+      index,
+      info: _types.TypeDefInfo.Plain,
+      name,
+      type: 'Null'
+    }));
+  } else if (isRustEnum(details)) {
+    value.sub = Object.entries(details).map((_ref, index) => {
+      let [name, typeOrObj] = _ref;
+      return (0, _util.objectSpread)({}, getTypeDef(getTypeString(typeOrObj || 'Null'), {
+        name
+      }, count), {
+        index
+      });
+    });
+  } else {
+    value.sub = Object.entries(details).map(_ref2 => {
+      let [name, index] = _ref2;
+      return {
+        index,
+        info: _types.TypeDefInfo.Plain,
+        name,
+        type: 'Null'
+      };
+    });
+  }
+
+  return value;
+} // decode a set of the form
+//   { _set: { A: 0b0001, B: 0b0010, C: 0b0100 } }
+
+
+function _decodeSet(value, details) {
+  value.info = _types.TypeDefInfo.Set;
+  value.length = details._bitLength;
+  value.sub = Object.entries(details).filter(_ref3 => {
+    let [name] = _ref3;
+    return !name.startsWith('_');
+  }).map(_ref4 => {
+    let [name, index] = _ref4;
+    return {
+      index,
+      info: _types.TypeDefInfo.Plain,
+      name,
+      type: 'Null'
+    };
+  });
+  return value;
+} // decode a struct, set or enum
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+function _decodeStruct(value, type, _, count) {
+  const parsed = JSON.parse(type);
+  const keys = Object.keys(parsed);
+
+  if (keys.length === 1 && keys[0] === '_enum') {
+    return _decodeEnum(value, parsed[keys[0]], count);
+  } else if (keys.length === 1 && keys[0] === '_set') {
+    return _decodeSet(value, parsed[keys[0]]);
+  }
+
+  value.alias = parsed._alias ? new Map(Object.entries(parsed._alias)) : undefined;
+  value.fallbackType = parsed._fallback;
+  value.sub = keys.filter(name => !KNOWN_INTERNALS.includes(name)).map(name => getTypeDef(getTypeString(parsed[name]), {
+    name
+  }, count));
+  return value;
+} // decode a fixed vector, e.g. [u8;32]
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+function _decodeFixedVec(value, type, _, count) {
+  const max = type.length - 1;
+  let index = -1;
+  let inner = 0;
+
+  for (let i = 1; i < max && index === -1; i++) {
+    if (type[i] === ';' && inner === 0) {
+      index = i;
+    } else if (['[', '(', '<'].includes(type[i])) {
+      inner++;
+    } else if ([']', ')', '>'].includes(type[i])) {
+      inner--;
+    }
+  }
+
+  (0, _util.assert)(index !== -1, () => `${type}: Unable to extract location of ';'`);
+  const vecType = type.substr(1, index - 1);
+  const [strLength, displayName] = type.substr(index + 1, max - index - 1).split(';');
+  const length = parseInt(strLength.trim(), 10); // as a first round, only u8 via u8aFixed, we can add more support
+
+  (0, _util.assert)(length <= 256, () => `${type}: Only support for [Type; <length>], where length <= 256`);
+  value.displayName = displayName;
+  value.length = length;
+  value.sub = getTypeDef(vecType, {}, count);
+  return value;
+}
+
+function _decodeRange(value, _, subType) {
+  const Type = getTypeDef(subType);
+  value.sub = [Type, Type];
+  return value;
+} // decode a tuple
+
+
+function _decodeTuple(value, _, subType, count) {
+  value.sub = subType.length === 0 ? [] : (0, _typeSplit.typeSplit)(subType).map(inner => getTypeDef(inner, {}, count));
+  return value;
+} // decode a Int/UInt<bitLength[, name]>
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+function _decodeAnyInt(value, type, _, clazz) {
+  const [strLength, displayName] = type.substr(clazz.length + 1, type.length - clazz.length - 1 - 1).split(',');
+  const length = parseInt(strLength.trim(), 10); // as a first round, only u8 via u8aFixed, we can add more support
+
+  (0, _util.assert)(length <= 8192 && length % 8 === 0, () => `${type}: Only support for ${clazz}<bitLength>, where length <= 8192 and a power of 8, found ${length}`);
+  value.displayName = displayName;
+  value.length = length;
+  return value;
+}
+
+function _decodeInt(value, type, subType) {
+  return _decodeAnyInt(value, type, subType, 'Int');
+}
+
+function _decodeUInt(value, type, subType) {
+  return _decodeAnyInt(value, type, subType, 'UInt');
+} // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+function _decodeDoNotConstruct(value, type, _) {
+  const NAME_LENGTH = 'DoNotConstruct'.length;
+  value.displayName = type.substr(NAME_LENGTH + 1, type.length - NAME_LENGTH - 1 - 1);
+  return value;
+}
+
+function hasWrapper(type, _ref5) {
+  let [start, end] = _ref5;
+  return type.substr(0, start.length) === start && type.substr(-1 * end.length) === end;
+}
+
+const nestedExtraction = [['[', ']', _types.TypeDefInfo.VecFixed, _decodeFixedVec], ['{', '}', _types.TypeDefInfo.Struct, _decodeStruct], ['(', ')', _types.TypeDefInfo.Tuple, _decodeTuple], // the inner for these are the same as tuple, multiple values
+['BTreeMap<', '>', _types.TypeDefInfo.BTreeMap, _decodeTuple], ['HashMap<', '>', _types.TypeDefInfo.HashMap, _decodeTuple], ['Int<', '>', _types.TypeDefInfo.Int, _decodeInt], // Not sure about these, have a specific implementation?
+['Range<', '>', _types.TypeDefInfo.Tuple, _decodeRange], ['RangeInclusive<', '>', _types.TypeDefInfo.Tuple, _decodeRange], ['Result<', '>', _types.TypeDefInfo.Result, _decodeTuple], ['UInt<', '>', _types.TypeDefInfo.UInt, _decodeUInt], ['DoNotConstruct<', '>', _types.TypeDefInfo.DoNotConstruct, _decodeDoNotConstruct]];
+const wrappedExtraction = [['BTreeSet<', '>', _types.TypeDefInfo.BTreeSet], ['Compact<', '>', _types.TypeDefInfo.Compact], ['Linkage<', '>', _types.TypeDefInfo.Linkage], ['Option<', '>', _types.TypeDefInfo.Option], ['Vec<', '>', _types.TypeDefInfo.Vec], ['WrapperOpaque<', '>', _types.TypeDefInfo.WrapperOpaque]];
+
+function extractSubType(type, _ref6) {
+  let [start, end] = _ref6;
+  return type.substr(start.length, type.length - start.length - end.length);
+} // eslint-disable-next-line @typescript-eslint/ban-types
+
+
+function getTypeDef(_type) {
+  let {
+    displayName,
+    name
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let count = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  // create the type via Type, allowing types to be sanitized
+  const type = (0, _typesCodec.sanitize)(_type);
+  const value = {
+    displayName,
+    info: _types.TypeDefInfo.Plain,
+    name,
+    type
+  };
+  (0, _util.assert)(++count !== MAX_NESTED, 'getTypeDef: Maximum nested limit reached');
+  const nested = nestedExtraction.find(nested => hasWrapper(type, nested));
+
+  if (nested) {
+    value.info = nested[2];
+    return nested[3](value, type, extractSubType(type, nested), count);
+  }
+
+  const wrapped = wrappedExtraction.find(wrapped => hasWrapper(type, wrapped));
+
+  if (wrapped) {
+    value.info = wrapped[2];
+    value.sub = getTypeDef(extractSubType(type, wrapped), {}, count);
+  }
+
+  return value;
+}

package/util/getTypeDef.d.ts

@@ -0,0 +1,7 @@
+import type { TypeDef } from '@polkadot/types-create/types';
+interface TypeDefOptions {
+    name?: string;
+    displayName?: string;
+}
+export declare function getTypeDef(_type: String | string, { displayName, name }?: TypeDefOptions, count?: number): TypeDef;
+export {};

package/util/getTypeDef.js

@@ -0,0 +1,201 @@
+// Copyright 2017-2021 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { sanitize } from '@polkadot/types-codec';
+import { assert, isNumber, isString, objectSpread } from '@polkadot/util';
+import { TypeDefInfo } from "../types.js";
+import { typeSplit } from "./typeSplit.js";
+const MAX_NESTED = 64;
+const KNOWN_INTERNALS = ['_alias', '_fallback'];
+
+function getTypeString(typeOrObj) {
+  return isString(typeOrObj) ? typeOrObj.toString() : JSON.stringify(typeOrObj);
+}
+
+function isRustEnum(details) {
+  const values = Object.values(details);
+
+  if (values.some(v => isNumber(v))) {
+    assert(values.every(v => isNumber(v) && v >= 0 && v <= 255), 'Invalid number-indexed enum definition');
+    return false;
+  }
+
+  return true;
+} // decode an enum of either of the following forms
+//  { _enum: ['A', 'B', 'C'] }
+//  { _enum: { A: AccountId, B: Balance, C: u32 } }
+//  { _enum: { A: 1, B: 2 } }
+
+
+function _decodeEnum(value, details, count) {
+  value.info = TypeDefInfo.Enum; // not as pretty, but remain compatible with oo7 for both struct and Array types
+
+  if (Array.isArray(details)) {
+    value.sub = details.map((name, index) => ({
+      index,
+      info: TypeDefInfo.Plain,
+      name,
+      type: 'Null'
+    }));
+  } else if (isRustEnum(details)) {
+    value.sub = Object.entries(details).map(([name, typeOrObj], index) => objectSpread({}, getTypeDef(getTypeString(typeOrObj || 'Null'), {
+      name
+    }, count), {
+      index
+    }));
+  } else {
+    value.sub = Object.entries(details).map(([name, index]) => ({
+      index,
+      info: TypeDefInfo.Plain,
+      name,
+      type: 'Null'
+    }));
+  }
+
+  return value;
+} // decode a set of the form
+//   { _set: { A: 0b0001, B: 0b0010, C: 0b0100 } }
+
+
+function _decodeSet(value, details) {
+  value.info = TypeDefInfo.Set;
+  value.length = details._bitLength;
+  value.sub = Object.entries(details).filter(([name]) => !name.startsWith('_')).map(([name, index]) => ({
+    index,
+    info: TypeDefInfo.Plain,
+    name,
+    type: 'Null'
+  }));
+  return value;
+} // decode a struct, set or enum
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+function _decodeStruct(value, type, _, count) {
+  const parsed = JSON.parse(type);
+  const keys = Object.keys(parsed);
+
+  if (keys.length === 1 && keys[0] === '_enum') {
+    return _decodeEnum(value, parsed[keys[0]], count);
+  } else if (keys.length === 1 && keys[0] === '_set') {
+    return _decodeSet(value, parsed[keys[0]]);
+  }
+
+  value.alias = parsed._alias ? new Map(Object.entries(parsed._alias)) : undefined;
+  value.fallbackType = parsed._fallback;
+  value.sub = keys.filter(name => !KNOWN_INTERNALS.includes(name)).map(name => getTypeDef(getTypeString(parsed[name]), {
+    name
+  }, count));
+  return value;
+} // decode a fixed vector, e.g. [u8;32]
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+function _decodeFixedVec(value, type, _, count) {
+  const max = type.length - 1;
+  let index = -1;
+  let inner = 0;
+
+  for (let i = 1; i < max && index === -1; i++) {
+    if (type[i] === ';' && inner === 0) {
+      index = i;
+    } else if (['[', '(', '<'].includes(type[i])) {
+      inner++;
+    } else if ([']', ')', '>'].includes(type[i])) {
+      inner--;
+    }
+  }
+
+  assert(index !== -1, () => `${type}: Unable to extract location of ';'`);
+  const vecType = type.substr(1, index - 1);
+  const [strLength, displayName] = type.substr(index + 1, max - index - 1).split(';');
+  const length = parseInt(strLength.trim(), 10); // as a first round, only u8 via u8aFixed, we can add more support
+
+  assert(length <= 256, () => `${type}: Only support for [Type; <length>], where length <= 256`);
+  value.displayName = displayName;
+  value.length = length;
+  value.sub = getTypeDef(vecType, {}, count);
+  return value;
+}
+
+function _decodeRange(value, _, subType) {
+  const Type = getTypeDef(subType);
+  value.sub = [Type, Type];
+  return value;
+} // decode a tuple
+
+
+function _decodeTuple(value, _, subType, count) {
+  value.sub = subType.length === 0 ? [] : typeSplit(subType).map(inner => getTypeDef(inner, {}, count));
+  return value;
+} // decode a Int/UInt<bitLength[, name]>
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+function _decodeAnyInt(value, type, _, clazz) {
+  const [strLength, displayName] = type.substr(clazz.length + 1, type.length - clazz.length - 1 - 1).split(',');
+  const length = parseInt(strLength.trim(), 10); // as a first round, only u8 via u8aFixed, we can add more support
+
+  assert(length <= 8192 && length % 8 === 0, () => `${type}: Only support for ${clazz}<bitLength>, where length <= 8192 and a power of 8, found ${length}`);
+  value.displayName = displayName;
+  value.length = length;
+  return value;
+}
+
+function _decodeInt(value, type, subType) {
+  return _decodeAnyInt(value, type, subType, 'Int');
+}
+
+function _decodeUInt(value, type, subType) {
+  return _decodeAnyInt(value, type, subType, 'UInt');
+} // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+function _decodeDoNotConstruct(value, type, _) {
+  const NAME_LENGTH = 'DoNotConstruct'.length;
+  value.displayName = type.substr(NAME_LENGTH + 1, type.length - NAME_LENGTH - 1 - 1);
+  return value;
+}
+
+function hasWrapper(type, [start, end]) {
+  return type.substr(0, start.length) === start && type.substr(-1 * end.length) === end;
+}
+
+const nestedExtraction = [['[', ']', TypeDefInfo.VecFixed, _decodeFixedVec], ['{', '}', TypeDefInfo.Struct, _decodeStruct], ['(', ')', TypeDefInfo.Tuple, _decodeTuple], // the inner for these are the same as tuple, multiple values
+['BTreeMap<', '>', TypeDefInfo.BTreeMap, _decodeTuple], ['HashMap<', '>', TypeDefInfo.HashMap, _decodeTuple], ['Int<', '>', TypeDefInfo.Int, _decodeInt], // Not sure about these, have a specific implementation?
+['Range<', '>', TypeDefInfo.Tuple, _decodeRange], ['RangeInclusive<', '>', TypeDefInfo.Tuple, _decodeRange], ['Result<', '>', TypeDefInfo.Result, _decodeTuple], ['UInt<', '>', TypeDefInfo.UInt, _decodeUInt], ['DoNotConstruct<', '>', TypeDefInfo.DoNotConstruct, _decodeDoNotConstruct]];
+const wrappedExtraction = [['BTreeSet<', '>', TypeDefInfo.BTreeSet], ['Compact<', '>', TypeDefInfo.Compact], ['Linkage<', '>', TypeDefInfo.Linkage], ['Option<', '>', TypeDefInfo.Option], ['Vec<', '>', TypeDefInfo.Vec], ['WrapperOpaque<', '>', TypeDefInfo.WrapperOpaque]];
+
+function extractSubType(type, [start, end]) {
+  return type.substr(start.length, type.length - start.length - end.length);
+} // eslint-disable-next-line @typescript-eslint/ban-types
+
+
+export function getTypeDef(_type, {
+  displayName,
+  name
+} = {}, count = 0) {
+  // create the type via Type, allowing types to be sanitized
+  const type = sanitize(_type);
+  const value = {
+    displayName,
+    info: TypeDefInfo.Plain,
+    name,
+    type
+  };
+  assert(++count !== MAX_NESTED, 'getTypeDef: Maximum nested limit reached');
+  const nested = nestedExtraction.find(nested => hasWrapper(type, nested));
+
+  if (nested) {
+    value.info = nested[2];
+    return nested[3](value, type, extractSubType(type, nested), count);
+  }
+
+  const wrapped = wrappedExtraction.find(wrapped => hasWrapper(type, wrapped));
+
+  if (wrapped) {
+    value.info = wrapped[2];
+    value.sub = getTypeDef(extractSubType(type, wrapped), {}, count);
+  }
+
+  return value;
+}

package/util/index.cjs

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _encodeTypes = require("./encodeTypes.cjs");
+
+Object.keys(_encodeTypes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _encodeTypes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _encodeTypes[key];
+    }
+  });
+});
+
+var _getTypeDef = require("./getTypeDef.cjs");
+
+Object.keys(_getTypeDef).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _getTypeDef[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _getTypeDef[key];
+    }
+  });
+});
+
+var _typeSplit = require("./typeSplit.cjs");
+
+Object.keys(_typeSplit).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _typeSplit[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _typeSplit[key];
+    }
+  });
+});

package/util/index.d.ts

@@ -0,0 +1,3 @@
+export * from './encodeTypes';
+export * from './getTypeDef';
+export * from './typeSplit';

package/util/index.js

@@ -0,0 +1,5 @@
+// Copyright 2017-2021 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export * from "./encodeTypes.js";
+export * from "./getTypeDef.js";
+export * from "./typeSplit.js";

package/util/typeSplit.cjs

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.typeSplit = typeSplit;
+
+var _util = require("@polkadot/util");
+
+// Copyright 2017-2021 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+function isNotNested() {
+  for (var _len = arguments.length, counters = new Array(_len), _key = 0; _key < _len; _key++) {
+    counters[_key] = arguments[_key];
+  }
+
+  return !counters.some(counter => counter !== 0);
+} // safely split a string on ', ' while taking care of any nested occurences
+
+
+function typeSplit(type) {
+  let [cDepth, fDepth, sDepth, tDepth, start] = [0, 0, 0, 0, 0];
+  const result = [];
+
+  const extract = index => {
+    if (isNotNested(cDepth, fDepth, sDepth, tDepth)) {
+      result.push(type.substr(start, index - start).trim());
+      start = index + 1;
+    }
+  };
+
+  for (let index = 0; index < type.length; index++) {
+    switch (type[index]) {
+      // if we are not nested, add the type
+      case ',':
+        extract(index);
+        break;
+      // adjust compact/vec (and friends) depth
+
+      case '<':
+        cDepth++;
+        break;
+
+      case '>':
+        cDepth--;
+        break;
+      // adjust fixed vec depths
+
+      case '[':
+        fDepth++;
+        break;
+
+      case ']':
+        fDepth--;
+        break;
+      // adjust struct depth
+
+      case '{':
+        sDepth++;
+        break;
+
+      case '}':
+        sDepth--;
+        break;
+      // adjust tuple depth
+
+      case '(':
+        tDepth++;
+        break;
+
+      case ')':
+        tDepth--;
+        break;
+    }
+  }
+
+  (0, _util.assert)(isNotNested(cDepth, fDepth, sDepth, tDepth), () => `Invalid definition (missing terminators) found in ${type}`); // the final leg of the journey
+
+  result.push(type.substr(start, type.length - start).trim());
+  return result;
+}

package/util/typeSplit.d.ts

@@ -0,0 +1 @@
+export declare function typeSplit(type: string): string[];

package/util/typeSplit.js

@@ -0,0 +1,70 @@
+// Copyright 2017-2021 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { assert } from '@polkadot/util';
+
+function isNotNested(...counters) {
+  return !counters.some(counter => counter !== 0);
+} // safely split a string on ', ' while taking care of any nested occurences
+
+
+export function typeSplit(type) {
+  let [cDepth, fDepth, sDepth, tDepth, start] = [0, 0, 0, 0, 0];
+  const result = [];
+
+  const extract = index => {
+    if (isNotNested(cDepth, fDepth, sDepth, tDepth)) {
+      result.push(type.substr(start, index - start).trim());
+      start = index + 1;
+    }
+  };
+
+  for (let index = 0; index < type.length; index++) {
+    switch (type[index]) {
+      // if we are not nested, add the type
+      case ',':
+        extract(index);
+        break;
+      // adjust compact/vec (and friends) depth
+
+      case '<':
+        cDepth++;
+        break;
+
+      case '>':
+        cDepth--;
+        break;
+      // adjust fixed vec depths
+
+      case '[':
+        fDepth++;
+        break;
+
+      case ']':
+        fDepth--;
+        break;
+      // adjust struct depth
+
+      case '{':
+        sDepth++;
+        break;
+
+      case '}':
+        sDepth--;
+        break;
+      // adjust tuple depth
+
+      case '(':
+        tDepth++;
+        break;
+
+      case ')':
+        tDepth--;
+        break;
+    }
+  }
+
+  assert(isNotNested(cDepth, fDepth, sDepth, tDepth), () => `Invalid definition (missing terminators) found in ${type}`); // the final leg of the journey
+
+  result.push(type.substr(start, type.length - start).trim());
+  return result;
+}