@polkadot/types-codec 8.5.1 → 8.5.2-10

package/cjs/abstract/AbstractArray.js

@@ -20,15 +20,9 @@ var _compareArray = require("../utils/compareArray");
  * @noInheritDoc
  */
 class AbstractArray extends Array {
-  constructor(registry, values, initialU8aLength) {
-    super(values.length); // explicitly set the values here - this removes the need for any extra allocations
-
-    for (let i = 0; i < values.length; i++) {
-      this[i] = values[i];
-    }
-
+  constructor(registry, length) {
+    super(length);
     this.registry = registry;
-    this.initialU8aLength = initialU8aLength;
   }
   /**
    * @description The length of the value when encoded as a Uint8Array
@@ -169,7 +163,7 @@ class AbstractArray extends Array {
 
   toU8a(isBare) {
     const encoded = this.toU8aInner();
-    return isBare ? (0, _util.u8aConcat)(...encoded) : (0, _util.u8aConcat)((0, _util.compactToU8a)(this.length), ...encoded);
+    return isBare ? (0, _util.u8aConcatStrict)(encoded) : (0, _util.u8aConcatStrict)([(0, _util.compactToU8a)(this.length), ...encoded]);
   }
 
   toU8aInner(isBare) {

package/cjs/base/Compact.js

@@ -11,7 +11,9 @@ var _utils = require("../utils");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-
+function noopSetDefinition(d) {
+  return d;
+}
 /**
  * @name Compact
  * @description
@@ -20,23 +22,36 @@ var _utils = require("../utils");
  * used by other types to add length-prefixed encoding, or in the case of wrapped types, taking
  * a number and making the compact representation thereof
  */
+
+
 class Compact {
   #Type;
   #raw;
 
   constructor(registry, Type) {
     let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
     this.registry = registry;
-    this.#Type = (0, _utils.typeToConstructor)(registry, Type);
+    this.#Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
     const [raw, decodedLength] = Compact.decodeCompact(registry, this.#Type, value);
     this.initialU8aLength = decodedLength;
     this.#raw = raw;
   }
 
   static with(Type) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Compact {
       constructor(registry, value) {
-        super(registry, Type, value);
+        super(registry, Type, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/cjs/base/Enum.js

@@ -13,6 +13,10 @@ var _Null = require("./Null");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+function noopSetDefinition(d) {
+  return d;
+}
+
 function isRustEnum(def) {
   const defValues = Object.values(def);
 
@@ -40,12 +44,11 @@ function extractDef(registry, _def) {
     isBasic = true;
     isIndexed = false;
   } else if (isRustEnum(_def)) {
-    const entries = Object.entries((0, _utils.mapToTypeMap)(registry, _def));
+    const [Types, keys] = (0, _utils.mapToTypeMap)(registry, _def);
 
-    for (let i = 0; i < entries.length; i++) {
-      const [key, Type] = entries[i];
-      def[key] = {
-        Type,
+    for (let i = 0; i < keys.length; i++) {
+      def[keys[i]] = {
+        Type: Types[i],
         index: i
       };
     }
@@ -147,11 +150,15 @@ class Enum {
   #raw;
 
   constructor(registry, Types, value, index) {
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
     const {
       def,
       isBasic,
       isIndexed
-    } = extractDef(registry, Types); // shortcut isU8a as used in SCALE decoding
+    } = definition || setDefinition(extractDef(registry, Types)); // shortcut isU8a as used in SCALE decoding
 
     const decoded = (0, _util.isU8a)(value) && value.length && !(0, _util.isNumber)(index) ? createFromValue(registry, def, value[0], value.subarray(1)) : decodeEnum(registry, def, value, index);
     this.registry = registry;
@@ -183,9 +190,16 @@ class Enum {
       isKeys[i] = `is${name}`;
     }
 
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Enum {
       constructor(registry, value, index) {
-        super(registry, Types, value, index);
+        super(registry, Types, value, index, {
+          definition,
+          setDefinition
+        });
         (0, _util.objectProperties)(this, isKeys, (_, i) => this.type === keys[i]);
         (0, _util.objectProperties)(this, asKeys, (k, i) => {
           (0, _util.assert)(this[isKeys[i]], () => `Cannot convert '${this.type}' via ${k}`);
@@ -386,14 +400,15 @@ class Enum {
       }, {}) : this.defKeys;
     }
 
-    const typeMap = Object.entries(this.#def).reduce((out, _ref3) => {
+    const entries = Object.entries(this.#def);
+    return (0, _utils.typesToMap)(this.registry, entries.reduce((out, _ref3, i) => {
       let [key, {
         Type
       }] = _ref3;
-      out[key] = Type;
+      out[0][i] = Type;
+      out[1][i] = key;
       return out;
-    }, {});
-    return (0, _utils.typesToMap)(this.registry, typeMap);
+    }, [new Array(entries.length), new Array(entries.length)]));
   }
   /**
    * @description Returns the base runtime type name for this instance
@@ -420,7 +435,7 @@ class Enum {
 
 
   toU8a(isBare) {
-    return (0, _util.u8aConcat)(new Uint8Array(isBare ? [] : [this.index]), this.#raw.toU8a(isBare));
+    return isBare ? this.#raw.toU8a(isBare) : (0, _util.u8aConcatStrict)([new Uint8Array([this.index]), this.#raw.toU8a(isBare)]);
   }
 
 }

package/cjs/base/Option.js

@@ -13,6 +13,10 @@ var _Null = require("./Null");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+function noopSetDefinition(d) {
+  return d;
+}
+
 class None extends _Null.Null {
   /**
    * @description Returns the base runtime type name for this instance
@@ -60,7 +64,11 @@ class Option {
   #raw;
 
   constructor(registry, typeName, value) {
-    const Type = (0, _utils.typeToConstructor)(registry, typeName);
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    const Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, typeName));
     const decoded = (0, _util.isU8a)(value) && value.length && !(0, _util.isCodec)(value) ? value[0] === 0 ? new None(registry) : new Type(registry, value.subarray(1)) : decodeOption(registry, Type, value);
     this.registry = registry;
     this.#Type = Type;
@@ -72,9 +80,19 @@ class Option {
   }
 
   static with(Type) {
+    let definition;
+
+    const setDefinition = d => {
+      definition = d;
+      return d;
+    };
+
     return class extends Option {
       constructor(registry, value) {
-        super(registry, Type, value);
+        super(registry, Type, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/cjs/base/Tuple.js

@@ -13,27 +13,29 @@ var _utils = require("../utils");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-
+function noopSetDefinition(d) {
+  return d;
+}
 /** @internal */
-function decodeTuple(registry, Classes, value) {
+
+
+function decodeTuple(registry, result, Classes, value) {
   if ((0, _util.isU8a)(value) || (0, _util.isHex)(value)) {
-    return (0, _utils.decodeU8a)(registry, (0, _util.u8aToU8a)(value), Classes);
+    return (0, _utils.decodeU8a)(registry, result, (0, _util.u8aToU8a)(value), Classes);
   }
 
-  const Types = Array.isArray(Classes) ? Classes : Object.values(Classes);
-  return [Types.map((Type, index) => {
-    try {
-      const entry = value === null || value === void 0 ? void 0 : value[index];
-
-      if (entry instanceof Type) {
-        return entry;
-      }
+  const Types = Classes[0];
 
-      return new Type(registry, entry);
+  for (let i = 0; i < Types.length; i++) {
+    try {
+      const entry = value === null || value === void 0 ? void 0 : value[i];
+      result[i] = entry instanceof Types[i] ? entry : new Types[i](registry, entry);
     } catch (error) {
-      throw new Error(`Tuple: failed on ${index}:: ${error.message}`);
+      throw new Error(`Tuple: failed on ${i}:: ${error.message}`);
     }
-  }), 0];
+  }
+
+  return [result, 0];
 }
 /**
  * @name Tuple
@@ -47,16 +49,28 @@ class Tuple extends _AbstractArray.AbstractArray {
   #Types;
 
   constructor(registry, Types, value) {
-    const Classes = Array.isArray(Types) ? Types.map(t => (0, _utils.typeToConstructor)(registry, t)) : (0, _util.isFunction)(Types) || (0, _util.isString)(Types) ? [(0, _utils.typeToConstructor)(registry, Types)] : (0, _utils.mapToTypeMap)(registry, Types);
-    const [values, decodedLength] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8a)(registry, value, Classes) : decodeTuple(registry, Classes, value);
-    super(registry, values, decodedLength);
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    const Classes = definition || setDefinition(Array.isArray(Types) ? [Types.map(t => (0, _utils.typeToConstructor)(registry, t)), []] : (0, _util.isFunction)(Types) || (0, _util.isString)(Types) ? [[(0, _utils.typeToConstructor)(registry, Types)], []] : (0, _utils.mapToTypeMap)(registry, Types));
+    super(registry, Classes[0].length);
+    const [, decodedLength] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8a)(registry, this, value, Classes, false) : decodeTuple(registry, this, Classes, value);
+    this.initialU8aLength = decodedLength;
     this.#Types = Classes;
   }
 
   static with(Types) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Tuple {
       constructor(registry, value) {
-        super(registry, Types, value);
+        super(registry, Types, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };
@@ -81,7 +95,7 @@ class Tuple extends _AbstractArray.AbstractArray {
 
 
   get Types() {
-    return Array.isArray(this.#Types) ? this.#Types.map(T => new T(this.registry).toRawType()) : Object.keys(this.#Types);
+    return this.#Types[1].length ? this.#Types[1] : this.#Types[0].map(T => new T(this.registry).toRawType());
   }
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
@@ -99,7 +113,7 @@ class Tuple extends _AbstractArray.AbstractArray {
 
 
   toRawType() {
-    const types = (Array.isArray(this.#Types) ? this.#Types : Object.values(this.#Types)).map(T => this.registry.getClassName(T) || new T(this.registry).toRawType());
+    const types = this.#Types[0].map(T => this.registry.getClassName(T) || new T(this.registry).toRawType());
     return `(${types.join(',')})`;
   }
   /**
@@ -118,7 +132,7 @@ class Tuple extends _AbstractArray.AbstractArray {
 
 
   toU8a(isBare) {
-    return (0, _util.u8aConcat)(...this.toU8aInner(isBare));
+    return (0, _util.u8aConcatStrict)(this.toU8aInner(isBare));
   }
 
 }

package/cjs/base/Vec.js

@@ -17,13 +17,26 @@ var _utils = require("../utils");
 const MAX_LENGTH = 64 * 1024;
 const l = (0, _util.logger)('Vec');
 
-function decodeVec(registry, Type, value) {
-  let length = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
+function noopSetDefinition(d) {
+  return d;
+}
+
+function decodeVecLength(value) {
+  if (Array.isArray(value)) {
+    return [value, value.length, 0];
+  }
+
+  const u8a = (0, _util.u8aToU8a)(value);
+  const [startAt, length] = (0, _util.compactFromU8aLim)(u8a);
+  (0, _util.assert)(length <= MAX_LENGTH, () => `Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  return [u8a, length, startAt];
+}
 
+function decodeVec(registry, result, value, startAt, Type) {
   if (Array.isArray(value)) {
-    const result = new Array(value.length);
+    const count = result.length;
 
-    for (let i = 0; i < value.length; i++) {
+    for (let i = 0; i < count; i++) {
       const entry = value[i];
 
       try {
@@ -34,20 +47,10 @@ function decodeVec(registry, Type, value) {
       }
     }
 
-    return [result, 0, 0];
+    return [0, 0];
   }
 
-  const u8a = (0, _util.u8aToU8a)(value);
-  let offset = 0;
-
-  if (length === -1) {
-    const [_offset, _length] = (0, _util.compactFromU8a)(u8a);
-    (0, _util.assert)(_length.lten(MAX_LENGTH), () => `Vec length ${_length.toString()} exceeds ${MAX_LENGTH}`);
-    length = _length.toNumber();
-    offset = _offset;
-  }
-
-  return (0, _utils.decodeU8aVec)(registry, u8a, offset, Type, length);
+  return (0, _utils.decodeU8aVec)(registry, result, (0, _util.u8aToU8a)(value), startAt, Type);
 }
 /**
  * @name Vec
@@ -63,16 +66,28 @@ class Vec extends _AbstractArray.AbstractArray {
 
   constructor(registry, Type) {
     let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-    const Clazz = (0, _utils.typeToConstructor)(registry, Type);
-    const [values, decodedLength] = decodeVec(registry, Clazz, value);
-    super(registry, values, decodedLength);
-    this.#Type = Clazz;
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    const [decodeFrom, length, startAt] = decodeVecLength(value);
+    super(registry, length);
+    this.#Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
+    const [decodedLength] = (0, _util.isU8a)(decodeFrom) ? (0, _utils.decodeU8aVec)(registry, this, decodeFrom, startAt, this.#Type) : decodeVec(registry, this, decodeFrom, startAt, this.#Type);
+    this.initialU8aLength = decodedLength;
   }
 
   static with(Type) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Vec {
       constructor(registry, value) {
-        super(registry, Type, value);
+        super(registry, Type, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/cjs/base/VecFixed.js

@@ -15,17 +15,8 @@ var _Vec = require("./Vec");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-
-/** @internal */
-function decodeVecFixed(registry, value, Type, length) {
-  const [values, decodedLength, decodedLengthNoOffset] = (0, _Vec.decodeVec)(registry, Type, value, length);
-
-  while (values.length < length) {
-    values.push(new Type(registry));
-  }
-
-  (0, _util.assert)(values.length === length, () => `Expected a length of exactly ${length} entries`);
-  return [values, decodedLength, decodedLengthNoOffset];
+function noopSetDefinition(d) {
+  return d;
 }
 /**
  * @name VecFixed
@@ -39,16 +30,27 @@ class VecFixed extends _AbstractArray.AbstractArray {
 
   constructor(registry, Type, length) {
     let value = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
-    const Clazz = (0, _utils.typeToConstructor)(registry, Type);
-    const [values,, decodedLengthNoOffset] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8aVec)(registry, value, 0, Clazz, length) : decodeVecFixed(registry, value, Clazz, length);
-    super(registry, values, decodedLengthNoOffset);
-    this.#Type = Clazz;
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    super(registry, length);
+    this.#Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
+    const [, decodedLengthNoOffset] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8aVec)(registry, this, value, 0, this.#Type) : (0, _Vec.decodeVec)(registry, this, value, 0, this.#Type);
+    this.initialU8aLength = decodedLengthNoOffset;
   }
 
   static with(Type, length) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends VecFixed {
       constructor(registry, value) {
-        super(registry, Type, length, value);
+        super(registry, Type, length, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };
@@ -90,7 +92,7 @@ class VecFixed extends _AbstractArray.AbstractArray {
     // we override, we don't add the length prefix for ourselves, and at the same time we
     // ignore isBare on entries, since they should be properly encoded at all times
     const encoded = this.toU8aInner();
-    return encoded.length ? (0, _util.u8aConcat)(...encoded) : new Uint8Array([]);
+    return encoded.length ? (0, _util.u8aConcatStrict)(encoded) : new Uint8Array([]);
   }
   /**
    * @description Returns the base runtime type name for this instance

package/cjs/extended/BTreeSet.js

@@ -16,11 +16,12 @@ const l = (0, _util.logger)('BTreeSet');
 
 function decodeSetFromU8a(registry, ValClass, u8a) {
   const output = new Set();
-  const [offset, length] = (0, _util.compactFromU8a)(u8a);
-  const [values, decodedLength] = (0, _utils.decodeU8aVec)(registry, u8a, offset, ValClass, length.toNumber());
+  const [offset, count] = (0, _util.compactFromU8aLim)(u8a);
+  const result = new Array(count);
+  const [decodedLength] = (0, _utils.decodeU8aVec)(registry, result, u8a, offset, ValClass);
 
-  for (let i = 0; i < values.length; i++) {
-    output.add(values[i]);
+  for (let i = 0; i < count; i++) {
+    output.add(result[i]);
   }
 
   return [ValClass, output, decodedLength];
@@ -221,7 +222,7 @@ class BTreeSet extends Set {
       encoded.push(v.toU8a(isBare));
     }
 
-    return (0, _util.u8aConcat)(...encoded);
+    return (0, _util.u8aConcatStrict)(encoded);
   }
 
 }

package/cjs/extended/BitVec.js

@@ -19,10 +19,10 @@ function decodeBitVecU8a(value) {
   } // handle all other Uint8Array inputs, these do have a length prefix which is the number of bits encoded
 
 
-  const [offset, length] = (0, _util.compactFromU8a)(value);
-  const total = offset + Math.ceil(length.toNumber() / 8);
+  const [offset, length] = (0, _util.compactFromU8aLim)(value);
+  const total = offset + Math.ceil(length / 8);
   (0, _util.assert)(total <= value.length, () => `BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
-  return [length.toNumber(), value.subarray(offset, total)];
+  return [length, value.subarray(offset, total)];
 }
 /** @internal */
 
@@ -94,7 +94,7 @@ class BitVec extends _Raw.Raw {
 
   toU8a(isBare) {
     const bitVec = super.toU8a();
-    return isBare ? bitVec : (0, _util.u8aConcat)((0, _util.compactToU8a)(this.#decodedLength), bitVec);
+    return isBare ? bitVec : (0, _util.u8aConcatStrict)([(0, _util.compactToU8a)(this.#decodedLength), bitVec]);
   }
 
 }

package/cjs/extended/Bytes.js

@@ -21,9 +21,9 @@ function decodeBytesU8a(value) {
   } // handle all other Uint8Array inputs, these do have a length prefix
 
 
-  const [offset, length] = (0, _util.compactFromU8a)(value);
-  const total = offset + length.toNumber();
-  (0, _util.assert)(length.lten(MAX_LENGTH), () => `Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  const [offset, length] = (0, _util.compactFromU8aLim)(value);
+  const total = offset + length;
+  (0, _util.assert)(length <= MAX_LENGTH, () => `Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
   (0, _util.assert)(total <= value.length, () => `Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
   return [value.subarray(offset, total), total];
 }
@@ -54,10 +54,10 @@ class Bytes extends _Raw.Raw {
    */
 
 
-  inspect() {
+  inspect(isBare) {
     const clength = (0, _util.compactToU8a)(this.length);
     return {
-      outer: this.length ? [clength, super.toU8a()] : [clength]
+      outer: isBare ? [super.toU8a()] : this.length ? [clength, super.toU8a()] : [clength]
     };
   }
   /**

package/cjs/extended/Map.js

@@ -22,15 +22,14 @@ const l = (0, _util.logger)('Map');
 
 function decodeMapFromU8a(registry, KeyClass, ValClass, u8a) {
   const output = new Map();
-  const [offset, length] = (0, _util.compactFromU8a)(u8a);
-  const count = length.toNumber();
+  const [offset, count] = (0, _util.compactFromU8aLim)(u8a);
   const types = [];
 
   for (let i = 0; i < count; i++) {
     types.push(KeyClass, ValClass);
   }
 
-  const [values, decodedLength] = (0, _utils.decodeU8a)(registry, u8a.subarray(offset), types);
+  const [values, decodedLength] = (0, _utils.decodeU8a)(registry, new Array(types.length), u8a.subarray(offset), [types, []]);
 
   for (let i = 0; i < values.length; i += 2) {
     output.set(values[i], values[i + 1]);
@@ -231,7 +230,7 @@ class CodecMap extends Map {
       encoded.push(k.toU8a(isBare), v.toU8a(isBare));
     }
 
-    return (0, _util.u8aConcat)(...encoded);
+    return (0, _util.u8aConcatStrict)(encoded);
   }
 
 }

package/cjs/extended/OptionBool.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OptionBool = void 0;
+
+var _util = require("@polkadot/util");
+
+var _Option = require("../base/Option");
+
+var _Bool = require("../native/Bool");
+
+// Copyright 2017-2022 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+function decodeU8a(registry, value) {
+  // Encoded as -
+  //  - 0 = None
+  //  - 1 = True
+  //  - 2 = False
+  return value[0] === 0 ? null : new _Bool.bool(registry, value[0] === 1);
+}
+/**
+ * @name OptionBool
+ * @description A specific implementation of Option<bool> than allows for single-byte encoding
+ */
+
+
+class OptionBool extends _Option.Option {
+  constructor(registry, value) {
+    super(registry, _Bool.bool, (0, _util.isU8a)(value) || (0, _util.isHex)(value) ? decodeU8a(registry, (0, _util.u8aToU8a)(value)) : value);
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    return 1;
+  }
+  /**
+   * @description The length of the initial encoded value (Only available when constructed from a Uint8Array)
+   */
+
+
+  get initialU8aLength() {
+    return 1;
+  }
+  /**
+   * @description Checks if the value is an empty value (always false)
+   */
+
+
+  get isFalse() {
+    return this.isSome ? !this.value.valueOf() : false;
+  }
+  /**
+   * @description Checks if the value is an empty value (always false)
+   */
+
+
+  get isTrue() {
+    return this.isSome ? this.value.valueOf() : false;
+  }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {
+      outer: [this.toU8a()]
+    };
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType(isBare) {
+    return isBare ? 'bool' : 'Option<bool>';
+  }
+  /**
+   * @description Encodes the value as a Uint8Array as per the SCALE specifications
+   * @param isBare true when the value has none of the type-specific prefixes (internal)
+   */
+
+
+  toU8a(isBare) {
+    if (isBare) {
+      return super.toU8a(true);
+    }
+
+    return this.isSome ? new Uint8Array([this.isTrue ? 1 : 2]) : new Uint8Array([0]);
+  }
+
+}
+
+exports.OptionBool = OptionBool;