@polkadot/types-codec 6.12.2-10

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 {};

package/base/Tuple.js

@@ -0,0 +1,116 @@
+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 { isFunction, isHex, isString, isU8a, stringify, u8aConcat, u8aToU8a } from '@polkadot/util';
+import { AbstractArray } from "../abstract/AbstractArray.js";
+import { decodeU8a, mapToTypeMap, typeToConstructor } from "../utils/index.js";
+
+/** @internal */
+function decodeTuple(registry, Classes, value) {
+  if (isU8a(value) || isHex(value)) {
+    return decodeU8a(registry, 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__*/_classPrivateFieldLooseKey("Types");
+
+export class Tuple extends AbstractArray {
+  constructor(registry, Types, value) {
+    const Classes = Array.isArray(Types) ? Types.map(t => typeToConstructor(registry, t)) : isFunction(Types) || isString(Types) ? [typeToConstructor(registry, Types)] : mapToTypeMap(registry, Types);
+    const [values, decodedLength] = isU8a(value) ? decodeU8a(registry, value, Classes) : decodeTuple(registry, Classes, value);
+    super(registry, values, decodedLength);
+    Object.defineProperty(this, _Types, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(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(_classPrivateFieldLooseBase(this, _Types)[_Types]) ? _classPrivateFieldLooseBase(this, _Types)[_Types].map(T => new T(this.registry).toRawType()) : Object.keys(_classPrivateFieldLooseBase(this, _Types)[_Types]);
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    const types = (Array.isArray(_classPrivateFieldLooseBase(this, _Types)[_Types]) ? _classPrivateFieldLooseBase(this, _Types)[_Types] : Object.values(_classPrivateFieldLooseBase(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 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 u8aConcat(...encoded);
+  }
+
+}

package/base/UInt.cjs

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UInt = void 0;
+
+var _AbstractInt = require("../abstract/AbstractInt.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name UInt
+ * @description
+ * A generic unsigned integer codec. For Substrate all numbers are Little Endian encoded,
+ * this handles the encoding and decoding of those numbers. Upon construction
+ * the bitLength is provided and any additional use keeps the number to this
+ * length. This extends `BN`, so all methods available on a normal `BN` object
+ * is available here.
+ * @noInheritDoc
+ */
+class UInt extends _AbstractInt.AbstractInt {
+  static with(bitLength, typeName) {
+    return class extends UInt {
+      constructor(registry, value) {
+        super(registry, value, bitLength);
+      }
+
+      toRawType() {
+        return typeName || super.toRawType();
+      }
+
+    };
+  }
+
+}
+
+exports.UInt = UInt;

package/base/UInt.d.ts

@@ -0,0 +1,15 @@
+import type { CodecClass, UIntBitLength } from '../types';
+import { AbstractInt } from '../abstract/AbstractInt';
+/**
+ * @name UInt
+ * @description
+ * A generic unsigned integer codec. For Substrate all numbers are Little Endian encoded,
+ * this handles the encoding and decoding of those numbers. Upon construction
+ * the bitLength is provided and any additional use keeps the number to this
+ * length. This extends `BN`, so all methods available on a normal `BN` object
+ * is available here.
+ * @noInheritDoc
+ */
+export declare class UInt extends AbstractInt {
+    static with(bitLength: UIntBitLength, typeName?: string): CodecClass<UInt>;
+}

package/base/UInt.js

@@ -0,0 +1,29 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { AbstractInt } from "../abstract/AbstractInt.js";
+/**
+ * @name UInt
+ * @description
+ * A generic unsigned integer codec. For Substrate all numbers are Little Endian encoded,
+ * this handles the encoding and decoding of those numbers. Upon construction
+ * the bitLength is provided and any additional use keeps the number to this
+ * length. This extends `BN`, so all methods available on a normal `BN` object
+ * is available here.
+ * @noInheritDoc
+ */
+
+export class UInt extends AbstractInt {
+  static with(bitLength, typeName) {
+    return class extends UInt {
+      constructor(registry, value) {
+        super(registry, value, bitLength);
+      }
+
+      toRawType() {
+        return typeName || super.toRawType();
+      }
+
+    };
+  }
+
+}