web-dc-api 0.0.60 → 0.0.62

package/dist/cjs/node_modules/@polkadot/types/metadata/decorate/constants/index.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var util = require('../util.js');
+var lazy = require('../../../../util/lazy.js');
+var camelCase = require('../../../../util/string/camelCase.js');
+var toU8a = require('../../../../util/hex/toU8a.js');
+
+/** @internal */
+function decorateConstants(registry, _ref, _version) {
+  let {
+    pallets
+  } = _ref;
+  const result = {};
+  for (let i = 0, count = pallets.length; i < count; i++) {
+    const {
+      constants,
+      name
+    } = pallets[i];
+    if (!constants.isEmpty) {
+      lazy.lazyMethod(result, camelCase.stringCamelCase(name), () => lazy.lazyMethods({}, constants, constant => {
+        const codec = registry.createTypeUnsafe(registry.createLookupType(constant.type), [toU8a.hexToU8a(constant.value.toHex())]);
+        // We are casting here since we are assigning to a read-only property
+        codec.meta = constant;
+        return codec;
+      }, util.objectNameToCamel));
+    }
+  }
+  return result;
+}
+
+exports.decorateConstants = decorateConstants;

package/dist/cjs/node_modules/@polkadot/types/metadata/decorate/errors/index.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var lazy$1 = require('../../../create/lazy.js');
+var util = require('../util.js');
+var lazy = require('../../../../util/lazy.js');
+var camelCase = require('../../../../util/string/camelCase.js');
+var codec = require('../../../../util/is/codec.js');
+var u8a = require('../../../../util/is/u8a.js');
+var spread = require('../../../../util/object/spread.js');
+
+function variantToMeta(lookup, variant) {
+  return spread.objectSpread({
+    args: variant.fields.map(_ref => {
+      let {
+        type
+      } = _ref;
+      return lookup.getTypeDef(type).type;
+    })
+  }, variant);
+}
+/** @internal */
+function decorateErrors(registry, _ref2, version) {
+  let {
+    lookup,
+    pallets
+  } = _ref2;
+  const result = {};
+  for (let i = 0, count = pallets.length; i < count; i++) {
+    const {
+      errors,
+      index,
+      name
+    } = pallets[i];
+    if (errors.isSome) {
+      const sectionIndex = version >= 12 ? index.toNumber() : i;
+      lazy.lazyMethod(result, camelCase.stringCamelCase(name), () => lazy$1.lazyVariants(lookup, errors.unwrap(), util.objectNameToString, variant => ({
+        // We sprinkle in isCodec & isU8a to ensure we are dealing with the correct objects
+        is: errorMod => codec.isCodec(errorMod) && codec.isCodec(errorMod.index) && errorMod.index.eq(sectionIndex) && (u8a.isU8a(errorMod.error) ? errorMod.error[0] === variant.index.toNumber() : codec.isCodec(errorMod.error) && errorMod.error.eq(variant.index)),
+        meta: registry.createTypeUnsafe('ErrorMetadataLatest', [variantToMeta(lookup, variant)])
+      })));
+    }
+  }
+  return result;
+}
+
+exports.decorateErrors = decorateErrors;
+exports.variantToMeta = variantToMeta;

package/dist/cjs/node_modules/@polkadot/types/metadata/decorate/events/index.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var lazy$1 = require('../../../create/lazy.js');
+var index = require('../errors/index.js');
+var util = require('../util.js');
+var lazy = require('../../../../util/lazy.js');
+var camelCase = require('../../../../util/string/camelCase.js');
+var codec = require('../../../../util/is/codec.js');
+var u8a = require('../../../../util/is/u8a.js');
+
+function filterEventsSome(_ref) {
+  let {
+    events
+  } = _ref;
+  return events.isSome;
+}
+/** @internal */
+function decorateEvents(registry, _ref2, version) {
+  let {
+    lookup,
+    pallets
+  } = _ref2;
+  const result = {};
+  const filtered = pallets.filter(filterEventsSome);
+  for (let i = 0, count = filtered.length; i < count; i++) {
+    const {
+      events,
+      index: index$1,
+      name
+    } = filtered[i];
+    const sectionIndex = version >= 12 ? index$1.toNumber() : i;
+    lazy.lazyMethod(result, camelCase.stringCamelCase(name), () => lazy$1.lazyVariants(lookup, events.unwrap(), util.objectNameToString, variant => ({
+      // We sprinkle in isCodec & isU8a to ensure we are dealing with the correct objects
+      is: eventRecord => codec.isCodec(eventRecord) && u8a.isU8a(eventRecord.index) && sectionIndex === eventRecord.index[0] && variant.index.eq(eventRecord.index[1]),
+      meta: registry.createTypeUnsafe('EventMetadataLatest', [index.variantToMeta(lookup, variant)])
+    })));
+  }
+  return result;
+}
+
+exports.decorateEvents = decorateEvents;
+exports.filterEventsSome = filterEventsSome;

package/dist/cjs/node_modules/@polkadot/types/metadata/decorate/extrinsics/createUnchecked.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var camelCase = require('../../../../util/string/camelCase.js');
+
+function isTx(tx, callIndex) {
+  return tx.callIndex[0] === callIndex[0] && tx.callIndex[1] === callIndex[1];
+}
+/** @internal */
+function createUnchecked(registry, section, callIndex, callMetadata) {
+  const expectedArgs = callMetadata.fields;
+  const funcName = camelCase.stringCamelCase(callMetadata.name);
+  const extrinsicFn = function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    if (expectedArgs.length !== args.length) {
+      throw new Error(`Extrinsic ${section}.${funcName} expects ${expectedArgs.length} arguments, got ${args.length}.`);
+    }
+    return registry.createTypeUnsafe('Call', [{
+      args,
+      callIndex
+    }, callMetadata]);
+  };
+  extrinsicFn.is = tx => isTx(tx, callIndex);
+  extrinsicFn.callIndex = callIndex;
+  extrinsicFn.meta = callMetadata;
+  extrinsicFn.method = funcName;
+  extrinsicFn.section = section;
+  extrinsicFn.toJSON = () => callMetadata.toJSON();
+  return extrinsicFn;
+}
+
+exports.createUnchecked = createUnchecked;

package/dist/cjs/node_modules/@polkadot/types/metadata/decorate/extrinsics/index.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var lazy$1 = require('../../../create/lazy.js');
+var util = require('../util.js');
+var createUnchecked = require('./createUnchecked.js');
+var getSiName = require('../../util/getSiName.js');
+var camelCase = require('../../../../util/string/camelCase.js');
+var lazy = require('../../../../util/lazy.js');
+var spread = require('../../../../util/object/spread.js');
+
+function filterCallsSome(_ref) {
+  let {
+    calls
+  } = _ref;
+  return calls.isSome;
+}
+function createCallFunction(registry, lookup, variant, sectionName, sectionIndex) {
+  const {
+    fields,
+    index
+  } = variant;
+  const count = fields.length;
+  const args = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const {
+      name,
+      type,
+      typeName
+    } = fields[i];
+    args[i] = spread.objectSpread({
+      name: camelCase.stringCamelCase(name.unwrapOr(`param${i}`)),
+      type: getSiName.getSiName(lookup, type)
+    }, typeName.isSome ? {
+      typeName: typeName.unwrap()
+    } : null);
+  }
+  return createUnchecked.createUnchecked(registry, sectionName, new Uint8Array([sectionIndex, index.toNumber()]), registry.createTypeUnsafe('FunctionMetadataLatest', [spread.objectSpread({
+    args
+  }, variant)]));
+}
+/** @internal */
+function decorateExtrinsics(registry, _ref2, version) {
+  let {
+    lookup,
+    pallets
+  } = _ref2;
+  const result = {};
+  const filtered = pallets.filter(filterCallsSome);
+  for (let i = 0, count = filtered.length; i < count; i++) {
+    const {
+      calls,
+      index,
+      name
+    } = filtered[i];
+    const sectionName = camelCase.stringCamelCase(name);
+    const sectionIndex = version >= 12 ? index.toNumber() : i;
+    lazy.lazyMethod(result, sectionName, () => lazy$1.lazyVariants(lookup, calls.unwrap(), util.objectNameToCamel, variant => createCallFunction(registry, lookup, variant, sectionName, sectionIndex)));
+  }
+  return result;
+}
+
+exports.createCallFunction = createCallFunction;
+exports.decorateExtrinsics = decorateExtrinsics;
+exports.filterCallsSome = filterCallsSome;

package/dist/cjs/node_modules/@polkadot/types/metadata/decorate/index.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var Metadata = require('../Metadata.js');
+var index = require('./constants/index.js');
+var index$1 = require('./errors/index.js');
+var index$2 = require('./events/index.js');
+var index$3 = require('./extrinsics/index.js');
+var index$4 = require('./storage/index.js');
+
+/**
+ * Expands the metadata by decoration into consts, query and tx sections
+ */
+function expandMetadata(registry, metadata) {
+  if (!(metadata instanceof Metadata.Metadata)) {
+    throw new Error('You need to pass a valid Metadata instance to Decorated');
+  }
+  const latest = metadata.asLatest;
+  const version = metadata.version;
+  return {
+    consts: index.decorateConstants(registry, latest),
+    errors: index$1.decorateErrors(registry, latest, version),
+    events: index$2.decorateEvents(registry, latest, version),
+    query: index$4.decorateStorage(registry, latest),
+    registry,
+    tx: index$3.decorateExtrinsics(registry, latest, version)
+  };
+}
+
+exports.decorateConstants = index.decorateConstants;
+exports.decorateErrors = index$1.decorateErrors;
+exports.decorateEvents = index$2.decorateEvents;
+exports.filterEventsSome = index$2.filterEventsSome;
+exports.decorateExtrinsics = index$3.decorateExtrinsics;
+exports.filterCallsSome = index$3.filterCallsSome;
+exports.decorateStorage = index$4.decorateStorage;
+exports.expandMetadata = expandMetadata;

package/dist/cjs/node_modules/@polkadot/types/metadata/decorate/storage/createFunction.js

@@ -0,0 +1,271 @@
+'use strict';
+
+var getHasher = require('./getHasher.js');
+var getSiName = require('../../util/getSiName.js');
+var concat = require('../../../../util/u8a/concat.js');
+var stripLength = require('../../../../util/compact/stripLength.js');
+var asU8a = require('../../../../util-crypto/xxhash/asU8a.js');
+var camelCase = require('../../../../util/string/camelCase.js');
+var spread = require('../../../../util/object/spread.js');
+var addLength = require('../../../../util/compact/addLength.js');
+var toU8a = require('../../../../util/u8a/toU8a.js');
+var _undefined = require('../../../../util/is/undefined.js');
+var Raw = require('../../../../types-codec/native/Raw.js');
+
+const NO_RAW_ARGS = {
+  args: [],
+  hashers: [],
+  keys: []
+};
+/** @internal */
+function filterDefined(a) {
+  return !_undefined.isUndefined(a);
+}
+/** @internal */
+function assertArgs(_ref, _ref2) {
+  let {
+    method,
+    section
+  } = _ref;
+  let {
+    args,
+    keys
+  } = _ref2;
+  if (!Array.isArray(args)) {
+    throw new Error(`Call to ${camelCase.stringCamelCase(section || 'unknown')}.${camelCase.stringCamelCase(method || 'unknown')} needs ${keys.length} arguments`);
+  } else if (args.filter(filterDefined).length !== keys.length) {
+    throw new Error(`Call to ${camelCase.stringCamelCase(section || 'unknown')}.${camelCase.stringCamelCase(method || 'unknown')} needs ${keys.length} arguments, found [${args.join(', ')}]`);
+  }
+}
+/** @internal */
+function createKeyRawParts(registry, itemFn, _ref3) {
+  let {
+    args,
+    hashers,
+    keys
+  } = _ref3;
+  const count = keys.length;
+  const extra = new Array(count);
+  for (let i = 0; i < count; i++) {
+    extra[i] = getHasher.getHasher(hashers[i])(registry.createTypeUnsafe(registry.createLookupType(keys[i]), [args[i]]).toU8a());
+  }
+  return [[asU8a.xxhashAsU8a(itemFn.prefix, 128), asU8a.xxhashAsU8a(itemFn.method, 128)], extra];
+}
+/** @internal */
+function createKeyInspect(registry, itemFn, args) {
+  assertArgs(itemFn, args);
+  const {
+    meta
+  } = itemFn;
+  const [prefix, extra] = createKeyRawParts(registry, itemFn, args);
+  let types = [];
+  if (meta.type.isMap) {
+    const {
+      hashers,
+      key
+    } = meta.type.asMap;
+    types = hashers.length === 1 ? [`${hashers[0].type}(${getSiName.getSiName(registry.lookup, key)})`] : registry.lookup.getSiType(key).def.asTuple.map((k, i) => `${hashers[i].type}(${getSiName.getSiName(registry.lookup, k)})`);
+  }
+  const names = ['module', 'method'].concat(...args.args.map((_, i) => types[i]));
+  return {
+    inner: prefix.concat(...extra).map((v, i) => ({
+      name: names[i],
+      outer: [v]
+    }))
+  };
+}
+/** @internal */
+function createKeyRaw(registry, itemFn, args) {
+  const [prefix, extra] = createKeyRawParts(registry, itemFn, args);
+  return concat.u8aConcat(...prefix, ...extra);
+}
+/** @internal */
+function createKey(registry, itemFn, args) {
+  assertArgs(itemFn, args);
+  // always add the length prefix (underlying it is Bytes)
+  return addLength.compactAddLength(createKeyRaw(registry, itemFn, args));
+}
+/** @internal */
+function createStorageInspect(registry, itemFn, options) {
+  const {
+    meta: {
+      type
+    }
+  } = itemFn;
+  return function () {
+    if (type.isPlain) {
+      return options.skipHashing ? {
+        inner: [],
+        name: 'wellKnown',
+        outer: [toU8a.u8aToU8a(options.key)]
+      } : createKeyInspect(registry, itemFn, NO_RAW_ARGS);
+    }
+    const {
+      hashers,
+      key
+    } = type.asMap;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return hashers.length === 1 ? createKeyInspect(registry, itemFn, {
+      args,
+      hashers,
+      keys: [key]
+    }) : createKeyInspect(registry, itemFn, {
+      args,
+      hashers,
+      keys: registry.lookup.getSiType(key).def.asTuple
+    });
+  };
+}
+/** @internal */
+function createStorageFn(registry, itemFn, options) {
+  const {
+    meta: {
+      type
+    }
+  } = itemFn;
+  let cacheKey = null;
+  // Can only have zero or one argument:
+  //   - storage.system.account(address)
+  //   - storage.timestamp.blockPeriod()
+  // For higher-map queries the params are passed in as an tuple, [key1, key2]
+  return function () {
+    if (type.isPlain) {
+      if (!cacheKey) {
+        cacheKey = options.skipHashing ? addLength.compactAddLength(toU8a.u8aToU8a(options.key)) : createKey(registry, itemFn, NO_RAW_ARGS);
+      }
+      return cacheKey;
+    }
+    const {
+      hashers,
+      key
+    } = type.asMap;
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    return hashers.length === 1 ? createKey(registry, itemFn, {
+      args,
+      hashers,
+      keys: [key]
+    }) : createKey(registry, itemFn, {
+      args,
+      hashers,
+      keys: registry.lookup.getSiType(key).def.asTuple
+    });
+  };
+}
+/** @internal */
+function createWithMeta(registry, itemFn, options) {
+  const {
+    meta,
+    method,
+    prefix,
+    section
+  } = itemFn;
+  const storageFn = createStorageFn(registry, itemFn, options);
+  storageFn.inspect = createStorageInspect(registry, itemFn, options);
+  storageFn.meta = meta;
+  storageFn.method = camelCase.stringCamelCase(method);
+  storageFn.prefix = prefix;
+  storageFn.section = section;
+  // explicitly add the actual method in the toJSON, this gets used to determine caching and without it
+  // instances (e.g. collective) will not work since it is only matched on param meta
+  storageFn.toJSON = () => spread.objectSpread({
+    storage: {
+      method,
+      prefix,
+      section
+    }
+  }, meta.toJSON());
+  return storageFn;
+}
+/** @internal */
+function extendHeadMeta(registry, _ref4, _ref5, iterFn) {
+  let {
+    meta: {
+      docs,
+      name,
+      type
+    },
+    section
+  } = _ref4;
+  let {
+    method
+  } = _ref5;
+  // metadata with a fallback value using the type of the key, the normal
+  // meta fallback only applies to actual entry values, create one for head
+  const meta = registry.createTypeUnsafe('StorageEntryMetadataLatest', [{
+    docs,
+    fallback: registry.createTypeUnsafe('Bytes', []),
+    modifier: registry.createTypeUnsafe('StorageEntryModifierLatest', [1]),
+    // required
+    name,
+    type: registry.createTypeUnsafe('StorageEntryTypeLatest', [type.asMap.key, 0])
+  }]);
+  iterFn.meta = meta;
+  const fn = function () {
+    return registry.createTypeUnsafe('StorageKey', [iterFn(...arguments), {
+      method,
+      section
+    }]);
+  };
+  fn.meta = meta;
+  return fn;
+}
+/** @internal */
+function extendPrefixedMap(registry, itemFn, storageFn) {
+  const {
+    meta: {
+      type
+    },
+    method,
+    section
+  } = itemFn;
+  storageFn.iterKey = extendHeadMeta(registry, itemFn, storageFn, function () {
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+    if (args.length && (type.isPlain || args.length >= type.asMap.hashers.length)) {
+      throw new Error(`Iteration of ${camelCase.stringCamelCase(section || 'unknown')}.${camelCase.stringCamelCase(method || 'unknown')} needs arguments to be at least one less than the full arguments, found [${args.join(', ')}]`);
+    }
+    if (args.length) {
+      if (type.isMap) {
+        const {
+          hashers,
+          key
+        } = type.asMap;
+        const keysVec = hashers.length === 1 ? [key] : registry.lookup.getSiType(key).def.asTuple;
+        return new Raw.Raw(registry, createKeyRaw(registry, itemFn, {
+          args,
+          hashers: hashers.slice(0, args.length),
+          keys: keysVec.slice(0, args.length)
+        }));
+      }
+    }
+    return new Raw.Raw(registry, createKeyRaw(registry, itemFn, NO_RAW_ARGS));
+  });
+  return storageFn;
+}
+/** @internal */
+function createFunction(registry, itemFn, options) {
+  const {
+    meta: {
+      type
+    }
+  } = itemFn;
+  const storageFn = createWithMeta(registry, itemFn, options);
+  if (type.isMap) {
+    extendPrefixedMap(registry, itemFn, storageFn);
+  }
+  storageFn.keyPrefix = function () {
+    return storageFn.iterKey && storageFn.iterKey(...arguments) || stripLength.compactStripLength(storageFn())[1];
+  };
+  return storageFn;
+}
+
+exports.NO_RAW_ARGS = NO_RAW_ARGS;
+exports.createFunction = createFunction;
+exports.createKeyInspect = createKeyInspect;
+exports.createKeyRaw = createKeyRaw;
+exports.createKeyRawParts = createKeyRawParts;

package/dist/cjs/node_modules/@polkadot/types/metadata/decorate/storage/getHasher.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var asU8a = require('../../../../util-crypto/xxhash/asU8a.js');
+var concat = require('../../../../util/u8a/concat.js');
+var toU8a = require('../../../../util/u8a/toU8a.js');
+var asU8a$1 = require('../../../../util-crypto/blake2/asU8a.js');
+
+const DEFAULT_FN = data => asU8a.xxhashAsU8a(data, 128);
+const HASHERS = {
+  Blake2_128: data =>
+  // eslint-disable-line camelcase
+  asU8a$1.blake2AsU8a(data, 128),
+  Blake2_128Concat: data =>
+  // eslint-disable-line camelcase
+  concat.u8aConcat(asU8a$1.blake2AsU8a(data, 128), toU8a.u8aToU8a(data)),
+  Blake2_256: data =>
+  // eslint-disable-line camelcase
+  asU8a$1.blake2AsU8a(data, 256),
+  Identity: data => toU8a.u8aToU8a(data),
+  Twox128: data => asU8a.xxhashAsU8a(data, 128),
+  Twox256: data => asU8a.xxhashAsU8a(data, 256),
+  Twox64Concat: data => concat.u8aConcat(asU8a.xxhashAsU8a(data, 64), toU8a.u8aToU8a(data))
+};
+/** @internal */
+function getHasher(hasher) {
+  return HASHERS[hasher.type] || DEFAULT_FN;
+}
+
+exports.getHasher = getHasher;

package/dist/cjs/node_modules/@polkadot/types/metadata/decorate/storage/getStorage.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var substrate = require('./substrate.js');
+
+/** @internal */
+function getStorage(registry) {
+  const storage = {};
+  const entries = Object.entries(substrate.substrate);
+  for (let e = 0, count = entries.length; e < count; e++) {
+    storage[entries[e][0]] = entries[e][1](registry);
+  }
+  return {
+    substrate: storage
+  };
+}
+
+exports.getStorage = getStorage;

package/dist/cjs/node_modules/@polkadot/types/metadata/decorate/storage/index.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var util$1 = require('../util.js');
+var createFunction = require('./createFunction.js');
+var getStorage = require('./getStorage.js');
+var util = require('./util.js');
+var camelCase = require('../../../../util/string/camelCase.js');
+var lazy = require('../../../../util/lazy.js');
+
+const VERSION_NAME = 'palletVersion';
+const VERSION_KEY = ':__STORAGE_VERSION__:';
+const VERSION_DOCS = {
+  docs: 'Returns the current pallet version from storage',
+  type: 'u16'
+};
+/** @internal */
+function decorateStorage(registry, _ref, _metaVersion) {
+  let {
+    pallets
+  } = _ref;
+  const result = getStorage.getStorage(registry);
+  for (let i = 0, count = pallets.length; i < count; i++) {
+    const {
+      name,
+      storage
+    } = pallets[i];
+    if (storage.isSome) {
+      const section = camelCase.stringCamelCase(name);
+      const {
+        items,
+        prefix: _prefix
+      } = storage.unwrap();
+      const prefix = _prefix.toString();
+      lazy.lazyMethod(result, section, () => lazy.lazyMethods({
+        palletVersion: util.createRuntimeFunction({
+          method: VERSION_NAME,
+          prefix,
+          section
+        }, createFunction.createKeyRaw(registry, {
+          method: VERSION_KEY,
+          prefix: name.toString()
+        }, createFunction.NO_RAW_ARGS), VERSION_DOCS)(registry)
+      }, items, meta => createFunction.createFunction(registry, {
+        meta,
+        method: meta.name.toString(),
+        prefix,
+        section
+      }, {}), util$1.objectNameToCamel));
+    }
+  }
+  return result;
+}
+
+exports.decorateStorage = decorateStorage;

package/dist/cjs/node_modules/@polkadot/types/metadata/decorate/storage/substrate.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var util = require('./util.js');
+
+const prefix = 'Substrate';
+const section = 'substrate';
+function createSubstrateFn(method, key, meta) {
+  return util.createRuntimeFunction({
+    method,
+    prefix,
+    section
+  }, key, meta);
+}
+const substrate = {
+  changesTrieConfig: createSubstrateFn('changesTrieConfig', ':changes_trie', {
+    docs: 'Changes trie configuration is stored under this key.',
+    type: 'u32'
+  }),
+  childStorageKeyPrefix: createSubstrateFn('childStorageKeyPrefix', ':child_storage:', {
+    docs: 'Prefix of child storage keys.',
+    type: 'u32'
+  }),
+  code: createSubstrateFn('code', ':code', {
+    docs: 'Wasm code of the runtime.',
+    type: 'Bytes'
+  }),
+  extrinsicIndex: createSubstrateFn('extrinsicIndex', ':extrinsic_index', {
+    docs: 'Current extrinsic index (u32) is stored under this key.',
+    type: 'u32'
+  }),
+  heapPages: createSubstrateFn('heapPages', ':heappages', {
+    docs: 'Number of wasm linear memory pages required for execution of the runtime.',
+    type: 'u64'
+  }),
+  intrablockEntropy: createSubstrateFn('intrablockEntropy', ':intrablock_entropy', {
+    docs: 'Current intra-block entropy (a universally unique `[u8; 32]` value) is stored here.',
+    type: '[u8; 32]'
+  })
+};
+
+exports.substrate = substrate;