@polkadot/types-codec 6.12.2-10

package/base/Null.js

@@ -0,0 +1,101 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { isNull } from '@polkadot/util';
+/**
+ * @name Null
+ * @description
+ * Implements a type that does not contain anything (apart from `null`)
+ */
+
+export class Null {
+  // Added for compatibility reasons, e.g. see Option
+  constructor(registry) {
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    this.initialU8aLength = 0;
+    this.registry = registry;
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    return 0;
+  }
+  /**
+   * @description returns a hash of the contents
+   */
+
+
+  get hash() {
+    throw new Error('.hash is not implemented on Null');
+  }
+  /**
+   * @description Checks if the value is an empty value (always true)
+   */
+
+
+  get isEmpty() {
+    return true;
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    return other instanceof Null || isNull(other);
+  }
+  /**
+   * @description Returns a hex string representation of the value
+   */
+
+
+  toHex() {
+    return '0x';
+  }
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+
+
+  toHuman() {
+    return this.toJSON();
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+
+
+  toJSON() {
+    return null;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return 'Null';
+  }
+  /**
+   * @description Returns the string representation of the value
+   */
+
+
+  toString() {
+    return '';
+  }
+  /**
+   * @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)
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+  toU8a(isBare) {
+    return new Uint8Array();
+  }
+
+}

package/base/Option.cjs

@@ -0,0 +1,256 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Option = void 0;
+
+var _classPrivateFieldLooseBase2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseBase"));
+
+var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseKey"));
+
+var _util = require("@polkadot/util");
+
+var _index = require("../utils/index.cjs");
+
+var _Null = require("./Null.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/** @internal */
+function decodeOption(registry, Type, value) {
+  // In the case of an option, unwrap the inner
+  if (value instanceof Option) {
+    value = value.value;
+  }
+
+  if ((0, _util.isNull)(value) || (0, _util.isUndefined)(value) || value instanceof _Null.Null || value === '0x') {
+    return new _Null.Null(registry);
+  } else if (value instanceof Type) {
+    // don't re-create, use as it (which also caters for derived types)
+    return value;
+  } else if ((0, _util.isU8a)(value)) {
+    // the isU8a check happens last in the if-tree - since the wrapped value
+    // may be an instance of it, so Type and Option checks go in first
+    return !value.length || value[0] === 0 ? new _Null.Null(registry) : new Type(registry, value.subarray(1));
+  }
+
+  return new Type(registry, value);
+}
+/**
+ * @name Option
+ * @description
+ * An Option is an optional field. Basically the first byte indicates that there is
+ * is value to follow. If the byte is `1` there is an actual value. So the Option
+ * implements that - decodes, checks for optionality and wraps the required structure
+ * with a value if/as required/found.
+ */
+
+
+var _Type = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("Type");
+
+var _initialU8aLength = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("initialU8aLength");
+
+var _raw = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("raw");
+
+class Option {
+  constructor(registry, typeName, value) {
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    Object.defineProperty(this, _Type, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _initialU8aLength, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _raw, {
+      writable: true,
+      value: void 0
+    });
+    const Type = (0, _index.typeToConstructor)(registry, typeName);
+    const decoded = (0, _util.isU8a)(value) && value.length && !(0, _util.isCodec)(value) ? value[0] === 0 ? new _Null.Null(registry) : new Type(registry, value.subarray(1)) : decodeOption(registry, Type, value);
+    this.registry = registry;
+    (0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type] = Type;
+    (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw] = decoded;
+
+    if (decoded.initialU8aLength) {
+      (0, _classPrivateFieldLooseBase2.default)(this, _initialU8aLength)[_initialU8aLength] = 1 + decoded.initialU8aLength;
+    }
+  }
+
+  static with(Type) {
+    return class extends Option {
+      constructor(registry, value) {
+        super(registry, Type, value);
+      }
+
+    };
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    // boolean byte (has value, doesn't have) along with wrapped length
+    return 1 + (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].encodedLength;
+  }
+  /**
+   * @description The length of the initial encoded value (Only available when constructed from a Uint8Array)
+   */
+
+
+  get initialU8aLength() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _initialU8aLength)[_initialU8aLength];
+  }
+  /**
+   * @description returns a hash of the contents
+   */
+
+
+  get hash() {
+    return this.registry.hash(this.toU8a());
+  }
+  /**
+   * @description Checks if the Option has no value
+   */
+
+
+  get isEmpty() {
+    return this.isNone;
+  }
+  /**
+   * @description Checks if the Option has no value
+   */
+
+
+  get isNone() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw] instanceof _Null.Null;
+  }
+  /**
+   * @description Checks if the Option has a value
+   */
+
+
+  get isSome() {
+    return !this.isNone;
+  }
+  /**
+   * @description The actual value for the Option
+   */
+
+
+  get value() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw];
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    if (other instanceof Option) {
+      return this.isSome === other.isSome && this.value.eq(other.value);
+    }
+
+    return this.value.eq(other);
+  }
+  /**
+   * @description Returns a hex string representation of the value
+   */
+
+
+  toHex() {
+    // This attempts to align with the JSON encoding - actually in this case
+    // the isSome value is correct, however the `isNone` may be problematic
+    return this.isNone ? '0x' : (0, _util.u8aToHex)(this.toU8a().subarray(1));
+  }
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+
+
+  toHuman(isExtended) {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].toHuman(isExtended);
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+
+
+  toJSON() {
+    return this.isNone ? null : (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].toJSON();
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType(isBare) {
+    const wrapped = this.registry.getClassName((0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type]) || new ((0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type])(this.registry).toRawType();
+    return isBare ? wrapped : `Option<${wrapped}>`;
+  }
+  /**
+   * @description Returns the string representation of the value
+   */
+
+
+  toString() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].toString();
+  }
+  /**
+   * @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 (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].toU8a(true);
+    }
+
+    const u8a = new Uint8Array(this.encodedLength);
+
+    if (this.isSome) {
+      u8a.set([1]);
+      u8a.set((0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw].toU8a(), 1);
+    }
+
+    return u8a;
+  }
+  /**
+   * @description Returns the value that the Option represents (if available), throws if null
+   */
+
+
+  unwrap() {
+    (0, _util.assert)(this.isSome, 'Option: unwrapping a None value');
+    return (0, _classPrivateFieldLooseBase2.default)(this, _raw)[_raw];
+  }
+  /**
+   * @description Returns the value that the Option represents (if available) or defaultValue if none
+   * @param defaultValue The value to return if the option isNone
+   */
+
+
+  unwrapOr(defaultValue) {
+    return this.isSome ? this.unwrap() : defaultValue;
+  }
+  /**
+   * @description Returns the value that the Option represents (if available) or defaultValue if none
+   * @param defaultValue The value to return if the option isNone
+   */
+
+
+  unwrapOrDefault() {
+    return this.isSome ? this.unwrap() : new ((0, _classPrivateFieldLooseBase2.default)(this, _Type)[_Type])(this.registry);
+  }
+
+}
+
+exports.Option = Option;

package/base/Option.d.ts

@@ -0,0 +1,88 @@
+import type { HexString } from '@polkadot/util/types';
+import type { AnyJson, Codec, CodecClass, CodecRegistry, IOption, IU8a } from '../types';
+/**
+ * @name Option
+ * @description
+ * An Option is an optional field. Basically the first byte indicates that there is
+ * is value to follow. If the byte is `1` there is an actual value. So the Option
+ * implements that - decodes, checks for optionality and wraps the required structure
+ * with a value if/as required/found.
+ */
+export declare class Option<T extends Codec> implements IOption<T> {
+    #private;
+    readonly registry: CodecRegistry;
+    createdAtHash?: IU8a;
+    constructor(registry: CodecRegistry, typeName: CodecClass<T> | string, value?: unknown);
+    static with<O extends Codec>(Type: CodecClass<O> | string): CodecClass<Option<O>>;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description The length of the initial encoded value (Only available when constructed from a Uint8Array)
+     */
+    get initialU8aLength(): number | undefined;
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash(): IU8a;
+    /**
+     * @description Checks if the Option has no value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Checks if the Option has no value
+     */
+    get isNone(): boolean;
+    /**
+     * @description Checks if the Option has a value
+     */
+    get isSome(): boolean;
+    /**
+     * @description The actual value for the Option
+     */
+    get value(): Codec;
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex(): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended?: boolean): AnyJson;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): AnyJson;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(isBare?: boolean): string;
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString(): string;
+    /**
+     * @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?: boolean): Uint8Array;
+    /**
+     * @description Returns the value that the Option represents (if available), throws if null
+     */
+    unwrap(): T;
+    /**
+     * @description Returns the value that the Option represents (if available) or defaultValue if none
+     * @param defaultValue The value to return if the option isNone
+     */
+    unwrapOr<O>(defaultValue: O): T | O;
+    /**
+     * @description Returns the value that the Option represents (if available) or defaultValue if none
+     * @param defaultValue The value to return if the option isNone
+     */
+    unwrapOrDefault(): T;
+}

package/base/Option.js

@@ -0,0 +1,240 @@
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/esm/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/esm/classPrivateFieldLooseKey";
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { assert, isCodec, isNull, isU8a, isUndefined, u8aToHex } from '@polkadot/util';
+import { typeToConstructor } from "../utils/index.js";
+import { Null } from "./Null.js";
+/** @internal */
+
+function decodeOption(registry, Type, value) {
+  // In the case of an option, unwrap the inner
+  if (value instanceof Option) {
+    value = value.value;
+  }
+
+  if (isNull(value) || isUndefined(value) || value instanceof Null || value === '0x') {
+    return new Null(registry);
+  } else if (value instanceof Type) {
+    // don't re-create, use as it (which also caters for derived types)
+    return value;
+  } else if (isU8a(value)) {
+    // the isU8a check happens last in the if-tree - since the wrapped value
+    // may be an instance of it, so Type and Option checks go in first
+    return !value.length || value[0] === 0 ? new Null(registry) : new Type(registry, value.subarray(1));
+  }
+
+  return new Type(registry, value);
+}
+/**
+ * @name Option
+ * @description
+ * An Option is an optional field. Basically the first byte indicates that there is
+ * is value to follow. If the byte is `1` there is an actual value. So the Option
+ * implements that - decodes, checks for optionality and wraps the required structure
+ * with a value if/as required/found.
+ */
+
+
+var _Type = /*#__PURE__*/_classPrivateFieldLooseKey("Type");
+
+var _initialU8aLength = /*#__PURE__*/_classPrivateFieldLooseKey("initialU8aLength");
+
+var _raw = /*#__PURE__*/_classPrivateFieldLooseKey("raw");
+
+export class Option {
+  constructor(registry, typeName, value) {
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    Object.defineProperty(this, _Type, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _initialU8aLength, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _raw, {
+      writable: true,
+      value: void 0
+    });
+    const Type = typeToConstructor(registry, typeName);
+    const decoded = isU8a(value) && value.length && !isCodec(value) ? value[0] === 0 ? new Null(registry) : new Type(registry, value.subarray(1)) : decodeOption(registry, Type, value);
+    this.registry = registry;
+    _classPrivateFieldLooseBase(this, _Type)[_Type] = Type;
+    _classPrivateFieldLooseBase(this, _raw)[_raw] = decoded;
+
+    if (decoded.initialU8aLength) {
+      _classPrivateFieldLooseBase(this, _initialU8aLength)[_initialU8aLength] = 1 + decoded.initialU8aLength;
+    }
+  }
+
+  static with(Type) {
+    return class extends Option {
+      constructor(registry, value) {
+        super(registry, Type, value);
+      }
+
+    };
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    // boolean byte (has value, doesn't have) along with wrapped length
+    return 1 + _classPrivateFieldLooseBase(this, _raw)[_raw].encodedLength;
+  }
+  /**
+   * @description The length of the initial encoded value (Only available when constructed from a Uint8Array)
+   */
+
+
+  get initialU8aLength() {
+    return _classPrivateFieldLooseBase(this, _initialU8aLength)[_initialU8aLength];
+  }
+  /**
+   * @description returns a hash of the contents
+   */
+
+
+  get hash() {
+    return this.registry.hash(this.toU8a());
+  }
+  /**
+   * @description Checks if the Option has no value
+   */
+
+
+  get isEmpty() {
+    return this.isNone;
+  }
+  /**
+   * @description Checks if the Option has no value
+   */
+
+
+  get isNone() {
+    return _classPrivateFieldLooseBase(this, _raw)[_raw] instanceof Null;
+  }
+  /**
+   * @description Checks if the Option has a value
+   */
+
+
+  get isSome() {
+    return !this.isNone;
+  }
+  /**
+   * @description The actual value for the Option
+   */
+
+
+  get value() {
+    return _classPrivateFieldLooseBase(this, _raw)[_raw];
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    if (other instanceof Option) {
+      return this.isSome === other.isSome && this.value.eq(other.value);
+    }
+
+    return this.value.eq(other);
+  }
+  /**
+   * @description Returns a hex string representation of the value
+   */
+
+
+  toHex() {
+    // This attempts to align with the JSON encoding - actually in this case
+    // the isSome value is correct, however the `isNone` may be problematic
+    return this.isNone ? '0x' : u8aToHex(this.toU8a().subarray(1));
+  }
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+
+
+  toHuman(isExtended) {
+    return _classPrivateFieldLooseBase(this, _raw)[_raw].toHuman(isExtended);
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+
+
+  toJSON() {
+    return this.isNone ? null : _classPrivateFieldLooseBase(this, _raw)[_raw].toJSON();
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType(isBare) {
+    const wrapped = this.registry.getClassName(_classPrivateFieldLooseBase(this, _Type)[_Type]) || new (_classPrivateFieldLooseBase(this, _Type)[_Type])(this.registry).toRawType();
+    return isBare ? wrapped : `Option<${wrapped}>`;
+  }
+  /**
+   * @description Returns the string representation of the value
+   */
+
+
+  toString() {
+    return _classPrivateFieldLooseBase(this, _raw)[_raw].toString();
+  }
+  /**
+   * @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 _classPrivateFieldLooseBase(this, _raw)[_raw].toU8a(true);
+    }
+
+    const u8a = new Uint8Array(this.encodedLength);
+
+    if (this.isSome) {
+      u8a.set([1]);
+      u8a.set(_classPrivateFieldLooseBase(this, _raw)[_raw].toU8a(), 1);
+    }
+
+    return u8a;
+  }
+  /**
+   * @description Returns the value that the Option represents (if available), throws if null
+   */
+
+
+  unwrap() {
+    assert(this.isSome, 'Option: unwrapping a None value');
+    return _classPrivateFieldLooseBase(this, _raw)[_raw];
+  }
+  /**
+   * @description Returns the value that the Option represents (if available) or defaultValue if none
+   * @param defaultValue The value to return if the option isNone
+   */
+
+
+  unwrapOr(defaultValue) {
+    return this.isSome ? this.unwrap() : defaultValue;
+  }
+  /**
+   * @description Returns the value that the Option represents (if available) or defaultValue if none
+   * @param defaultValue The value to return if the option isNone
+   */
+
+
+  unwrapOrDefault() {
+    return this.isSome ? this.unwrap() : new (_classPrivateFieldLooseBase(this, _Type)[_Type])(this.registry);
+  }
+
+}