@polkadot/types-codec 6.12.2-2

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);
+  }
+
+}

package/base/Result.cjs

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Result = void 0;
+
+var _util = require("@polkadot/util");
+
+var _Enum = require("./Enum.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name Result
+ * @description
+ * A Result maps to the Rust Result type, that can either wrap a success or error value
+ */
+class Result extends _Enum.Enum {
+  constructor(registry, Ok, Err, value) {
+    // NOTE This is order-dependent, Ok (with index 0) needs to be first
+    // eslint-disable-next-line sort-keys
+    super(registry, {
+      Ok,
+      Err
+    }, value);
+  }
+
+  static with(Types) {
+    return class extends Result {
+      constructor(registry, value) {
+        super(registry, Types.Ok, Types.Err, value);
+      }
+
+    };
+  }
+  /**
+   * @description Returns the wrapper Err value (if isErr)
+   */
+
+
+  get asErr() {
+    (0, _util.assert)(this.isErr, 'Cannot extract Err value from Ok result, check isErr first');
+    return this.value;
+  }
+  /**
+   * @deprecated Use asErr
+   */
+
+
+  get asError() {
+    return this.asErr;
+  }
+  /**
+   * @description Returns the wrapper Ok value (if isOk)
+   */
+
+
+  get asOk() {
+    (0, _util.assert)(this.isOk, 'Cannot extract Ok value from Err result, check isOk first');
+    return this.value;
+  }
+  /**
+   * @description Checks if the Result has no value
+   */
+
+
+  get isEmpty() {
+    return this.isOk && this.value.isEmpty;
+  }
+  /**
+   * @description Checks if the Result wraps an Err value
+   */
+
+
+  get isErr() {
+    return !this.isOk;
+  }
+  /**
+   * @deprecated Use isErr
+   */
+
+
+  get isError() {
+    return this.isErr;
+  }
+  /**
+   * @description Checks if the Result wraps an Ok value
+   */
+
+
+  get isOk() {
+    return this.index === 0;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    const Types = this._toRawStruct();
+
+    return `Result<${Types.Ok},${Types.Err}>`;
+  }
+
+}
+
+exports.Result = Result;

package/base/Result.d.ts

@@ -0,0 +1,46 @@
+import type { Codec, CodecClass, CodecRegistry, IResult } from '../types';
+import { Enum } from './Enum';
+/**
+ * @name Result
+ * @description
+ * A Result maps to the Rust Result type, that can either wrap a success or error value
+ */
+export declare class Result<O extends Codec, E extends Codec> extends Enum implements IResult<O, E> {
+    constructor(registry: CodecRegistry, Ok: CodecClass<O> | string, Err: CodecClass<E> | string, value?: unknown);
+    static with<O extends Codec, E extends Codec>(Types: {
+        Ok: CodecClass<O> | string;
+        Err: CodecClass<E> | string;
+    }): CodecClass<Result<O, E>>;
+    /**
+     * @description Returns the wrapper Err value (if isErr)
+     */
+    get asErr(): E;
+    /**
+     * @deprecated Use asErr
+     */
+    get asError(): E;
+    /**
+     * @description Returns the wrapper Ok value (if isOk)
+     */
+    get asOk(): O;
+    /**
+     * @description Checks if the Result has no value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Checks if the Result wraps an Err value
+     */
+    get isErr(): boolean;
+    /**
+     * @deprecated Use isErr
+     */
+    get isError(): boolean;
+    /**
+     * @description Checks if the Result wraps an Ok value
+     */
+    get isOk(): boolean;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}

package/base/Result.js

@@ -0,0 +1,98 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { assert } from '@polkadot/util';
+import { Enum } from "./Enum.js";
+/**
+ * @name Result
+ * @description
+ * A Result maps to the Rust Result type, that can either wrap a success or error value
+ */
+
+export class Result extends Enum {
+  constructor(registry, Ok, Err, value) {
+    // NOTE This is order-dependent, Ok (with index 0) needs to be first
+    // eslint-disable-next-line sort-keys
+    super(registry, {
+      Ok,
+      Err
+    }, value);
+  }
+
+  static with(Types) {
+    return class extends Result {
+      constructor(registry, value) {
+        super(registry, Types.Ok, Types.Err, value);
+      }
+
+    };
+  }
+  /**
+   * @description Returns the wrapper Err value (if isErr)
+   */
+
+
+  get asErr() {
+    assert(this.isErr, 'Cannot extract Err value from Ok result, check isErr first');
+    return this.value;
+  }
+  /**
+   * @deprecated Use asErr
+   */
+
+
+  get asError() {
+    return this.asErr;
+  }
+  /**
+   * @description Returns the wrapper Ok value (if isOk)
+   */
+
+
+  get asOk() {
+    assert(this.isOk, 'Cannot extract Ok value from Err result, check isOk first');
+    return this.value;
+  }
+  /**
+   * @description Checks if the Result has no value
+   */
+
+
+  get isEmpty() {
+    return this.isOk && this.value.isEmpty;
+  }
+  /**
+   * @description Checks if the Result wraps an Err value
+   */
+
+
+  get isErr() {
+    return !this.isOk;
+  }
+  /**
+   * @deprecated Use isErr
+   */
+
+
+  get isError() {
+    return this.isErr;
+  }
+  /**
+   * @description Checks if the Result wraps an Ok value
+   */
+
+
+  get isOk() {
+    return this.index === 0;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    const Types = this._toRawStruct();
+
+    return `Result<${Types.Ok},${Types.Err}>`;
+  }
+
+}

package/base/Tuple.cjs

@@ -0,0 +1,132 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Tuple = void 0;
+
+var _classPrivateFieldLooseBase2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseBase"));
+
+var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseKey"));
+
+var _util = require("@polkadot/util");
+
+var _AbstractArray = require("../abstract/AbstractArray.cjs");
+
+var _index = require("../utils/index.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/** @internal */
+function decodeTuple(registry, Classes, value) {
+  if ((0, _util.isU8a)(value) || (0, _util.isHex)(value)) {
+    return (0, _index.decodeU8a)(registry, (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;
+      }
+
+      return new Type(registry, entry);
+    } catch (error) {
+      throw new Error(`Tuple: failed on ${index}:: ${error.message}`);
+    }
+  }), 0];
+}
+/**
+ * @name Tuple
+ * @description
+ * A Tuple defines an anonymous fixed-length array, where each element has its
+ * own type. It extends the base JS `Array` object.
+ */
+
+
+var _Types = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("Types");
+
+class Tuple extends _AbstractArray.AbstractArray {
+  constructor(registry, Types, value) {
+    const Classes = Array.isArray(Types) ? Types.map(t => (0, _index.typeToConstructor)(registry, t)) : (0, _util.isFunction)(Types) || (0, _util.isString)(Types) ? [(0, _index.typeToConstructor)(registry, Types)] : (0, _index.mapToTypeMap)(registry, Types);
+    const [values, decodedLength] = (0, _util.isU8a)(value) ? (0, _index.decodeU8a)(registry, value, Classes) : decodeTuple(registry, Classes, value);
+    super(registry, values, decodedLength);
+    Object.defineProperty(this, _Types, {
+      writable: true,
+      value: void 0
+    });
+    (0, _classPrivateFieldLooseBase2.default)(this, _Types)[_Types] = Classes;
+  }
+
+  static with(Types) {
+    return class extends Tuple {
+      constructor(registry, value) {
+        super(registry, Types, value);
+      }
+
+    };
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    let total = 0;
+
+    for (let i = 0; i < this.length; i++) {
+      total += this[i].encodedLength;
+    }
+
+    return total;
+  }
+  /**
+   * @description The types definition of the tuple
+   */
+
+
+  get Types() {
+    return Array.isArray((0, _classPrivateFieldLooseBase2.default)(this, _Types)[_Types]) ? (0, _classPrivateFieldLooseBase2.default)(this, _Types)[_Types].map(T => new T(this.registry).toRawType()) : Object.keys((0, _classPrivateFieldLooseBase2.default)(this, _Types)[_Types]);
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    const types = (Array.isArray((0, _classPrivateFieldLooseBase2.default)(this, _Types)[_Types]) ? (0, _classPrivateFieldLooseBase2.default)(this, _Types)[_Types] : Object.values((0, _classPrivateFieldLooseBase2.default)(this, _Types)[_Types])).map(T => this.registry.getClassName(T) || new T(this.registry).toRawType());
+    return `(${types.join(',')})`;
+  }
+  /**
+   * @description Returns the string representation of the value
+   */
+
+
+  toString() {
+    // Overwrite the default toString representation of Array.
+    return (0, _util.stringify)(this.toJSON());
+  }
+  /**
+   * @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) {
+    const encoded = new Array(this.length);
+
+    for (let i = 0; i < this.length; i++) {
+      encoded[i] = this[i].toU8a(isBare);
+    }
+
+    return (0, _util.u8aConcat)(...encoded);
+  }
+
+}
+
+exports.Tuple = Tuple;

package/base/Tuple.d.ts

@@ -0,0 +1,39 @@
+import type { AnyTupleValue, Codec, CodecClass, CodecRegistry, ITuple } from '../types';
+import { AbstractArray } from '../abstract/AbstractArray';
+declare type TupleType = (CodecClass | string);
+declare type TupleTypes = TupleType[] | {
+    [index: string]: CodecClass | string;
+};
+/**
+ * @name Tuple
+ * @description
+ * A Tuple defines an anonymous fixed-length array, where each element has its
+ * own type. It extends the base JS `Array` object.
+ */
+export declare class Tuple extends AbstractArray<Codec> implements ITuple<Codec[]> {
+    #private;
+    constructor(registry: CodecRegistry, Types: TupleTypes | TupleType, value?: AnyTupleValue);
+    static with(Types: TupleTypes | TupleType): CodecClass<Tuple>;
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description The types definition of the tuple
+     */
+    get Types(): string[];
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): 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;
+}
+export {};