@polkadot/types-codec 6.12.2-10

package/extended/BitVec.cjs

@@ -0,0 +1,97 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BitVec = void 0;
+
+var _classPrivateFieldLooseBase2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseBase"));
+
+var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseKey"));
+
+var _util = require("@polkadot/util");
+
+var _Raw = require("../native/Raw.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/** @internal */
+function decodeBitVecU8a(value) {
+  if (!value || !value.length) {
+    return [0, new Uint8Array()];
+  } // 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);
+  (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)];
+}
+/** @internal */
+
+
+function decodeBitVec(value) {
+  if (Array.isArray(value) || (0, _util.isString)(value)) {
+    const u8a = (0, _util.u8aToU8a)(value);
+    return [u8a.length / 8, u8a];
+  }
+
+  return decodeBitVecU8a(value);
+}
+/**
+ * @name BitVec
+ * @description
+ * A BitVec that represents an array of bits. The bits are however stored encoded. The difference between this
+ * and a normal Bytes would be that the length prefix indicates the number of bits encoded, not the bytes
+ */
+
+
+var _decodedLength = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("decodedLength");
+
+class BitVec extends _Raw.Raw {
+  constructor(registry, value) {
+    const [decodedLength, u8a] = decodeBitVec(value);
+    super(registry, u8a);
+    Object.defineProperty(this, _decodedLength, {
+      writable: true,
+      value: void 0
+    });
+    (0, _classPrivateFieldLooseBase2.default)(this, _decodedLength)[_decodedLength] = decodedLength;
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    return this.length + (0, _util.compactToU8a)((0, _classPrivateFieldLooseBase2.default)(this, _decodedLength)[_decodedLength]).length;
+  }
+
+  toHuman() {
+    return `0b${[...this.toU8a(true)].map(d => `00000000${d.toString(2)}`.slice(-8)).join('_')}`;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return 'BitVec';
+  }
+  /**
+   * @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 bitVec = super.toU8a();
+    return isBare ? bitVec : (0, _util.u8aConcat)((0, _util.compactToU8a)((0, _classPrivateFieldLooseBase2.default)(this, _decodedLength)[_decodedLength]), bitVec);
+  }
+
+}
+
+exports.BitVec = BitVec;

package/extended/BitVec.d.ts

@@ -0,0 +1,26 @@
+import type { AnyU8a, CodecRegistry } from '../types';
+import { Raw } from '../native/Raw';
+/**
+ * @name BitVec
+ * @description
+ * A BitVec that represents an array of bits. The bits are however stored encoded. The difference between this
+ * and a normal Bytes would be that the length prefix indicates the number of bits encoded, not the bytes
+ */
+export declare class BitVec extends Raw {
+    #private;
+    constructor(registry: CodecRegistry, value?: AnyU8a);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    toHuman(): string;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): 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;
+}

package/extended/BitVec.js

@@ -0,0 +1,82 @@
+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, compactFromU8a, compactToU8a, isString, u8aConcat, u8aToU8a } from '@polkadot/util';
+import { Raw } from "../native/Raw.js";
+/** @internal */
+
+function decodeBitVecU8a(value) {
+  if (!value || !value.length) {
+    return [0, new Uint8Array()];
+  } // handle all other Uint8Array inputs, these do have a length prefix which is the number of bits encoded
+
+
+  const [offset, length] = compactFromU8a(value);
+  const total = offset + Math.ceil(length.toNumber() / 8);
+  assert(total <= value.length, () => `BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
+  return [length.toNumber(), value.subarray(offset, total)];
+}
+/** @internal */
+
+
+function decodeBitVec(value) {
+  if (Array.isArray(value) || isString(value)) {
+    const u8a = u8aToU8a(value);
+    return [u8a.length / 8, u8a];
+  }
+
+  return decodeBitVecU8a(value);
+}
+/**
+ * @name BitVec
+ * @description
+ * A BitVec that represents an array of bits. The bits are however stored encoded. The difference between this
+ * and a normal Bytes would be that the length prefix indicates the number of bits encoded, not the bytes
+ */
+
+
+var _decodedLength = /*#__PURE__*/_classPrivateFieldLooseKey("decodedLength");
+
+export class BitVec extends Raw {
+  constructor(registry, value) {
+    const [decodedLength, u8a] = decodeBitVec(value);
+    super(registry, u8a);
+    Object.defineProperty(this, _decodedLength, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _decodedLength)[_decodedLength] = decodedLength;
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    return this.length + compactToU8a(_classPrivateFieldLooseBase(this, _decodedLength)[_decodedLength]).length;
+  }
+
+  toHuman() {
+    return `0b${[...this.toU8a(true)].map(d => `00000000${d.toString(2)}`.slice(-8)).join('_')}`;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return 'BitVec';
+  }
+  /**
+   * @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 bitVec = super.toU8a();
+    return isBare ? bitVec : u8aConcat(compactToU8a(_classPrivateFieldLooseBase(this, _decodedLength)[_decodedLength]), bitVec);
+  }
+
+}

package/extended/Bytes.cjs

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Bytes = void 0;
+
+var _util = require("@polkadot/util");
+
+var _Raw = require("../native/Raw.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// Bytes are used for things like on-chain code, so it has a healthy limit
+const MAX_LENGTH = 10 * 1024 * 1024;
+/** @internal */
+
+function decodeBytesU8a(value) {
+  if (!value.length) {
+    return [new Uint8Array(), 0];
+  } // 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}`);
+  (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];
+}
+/** @internal */
+
+
+function decodeBytes(value) {
+  if (Array.isArray(value) || (0, _util.isString)(value)) {
+    return [(0, _util.u8aToU8a)(value), 0];
+  } else if (!(value instanceof _Raw.Raw) && (0, _util.isU8a)(value)) {
+    // We are ensuring we are not a Raw instance. In the case of a Raw we already have gotten
+    // rid of the length, i.e. new Bytes(new Bytes(...)) will work as expected
+    return decodeBytesU8a(value);
+  }
+
+  return [value, 0];
+}
+/**
+ * @name Bytes
+ * @description
+ * A Bytes wrapper for Vec<u8>. The significant difference between this and a normal Uint8Array
+ * is that this version allows for length-encoding. (i.e. it is a variable-item codec, the same
+ * as what is found in [[Text]] and [[Vec]])
+ */
+
+
+class Bytes extends _Raw.Raw {
+  constructor(registry, value) {
+    const [u8a, decodedLength] = decodeBytes(value);
+    super(registry, u8a, decodedLength);
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    return this.length + (0, _util.compactToU8a)(this.length).length;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return 'Bytes';
+  }
+  /**
+   * @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) {
+    return isBare ? super.toU8a(isBare) : (0, _util.compactAddLength)(this);
+  }
+
+}
+
+exports.Bytes = Bytes;

package/extended/Bytes.d.ts

@@ -0,0 +1,25 @@
+import type { AnyU8a, CodecRegistry } from '../types';
+import { Raw } from '../native/Raw';
+/**
+ * @name Bytes
+ * @description
+ * A Bytes wrapper for Vec<u8>. The significant difference between this and a normal Uint8Array
+ * is that this version allows for length-encoding. (i.e. it is a variable-item codec, the same
+ * as what is found in [[Text]] and [[Vec]])
+ */
+export declare class Bytes extends Raw {
+    constructor(registry: CodecRegistry, value?: AnyU8a);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): 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;
+}

package/extended/Bytes.js

@@ -0,0 +1,75 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { assert, compactAddLength, compactFromU8a, compactToU8a, isString, isU8a, u8aToU8a } from '@polkadot/util';
+import { Raw } from "../native/Raw.js"; // Bytes are used for things like on-chain code, so it has a healthy limit
+
+const MAX_LENGTH = 10 * 1024 * 1024;
+/** @internal */
+
+function decodeBytesU8a(value) {
+  if (!value.length) {
+    return [new Uint8Array(), 0];
+  } // handle all other Uint8Array inputs, these do have a length prefix
+
+
+  const [offset, length] = compactFromU8a(value);
+  const total = offset + length.toNumber();
+  assert(length.lten(MAX_LENGTH), () => `Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  assert(total <= value.length, () => `Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
+  return [value.subarray(offset, total), total];
+}
+/** @internal */
+
+
+function decodeBytes(value) {
+  if (Array.isArray(value) || isString(value)) {
+    return [u8aToU8a(value), 0];
+  } else if (!(value instanceof Raw) && isU8a(value)) {
+    // We are ensuring we are not a Raw instance. In the case of a Raw we already have gotten
+    // rid of the length, i.e. new Bytes(new Bytes(...)) will work as expected
+    return decodeBytesU8a(value);
+  }
+
+  return [value, 0];
+}
+/**
+ * @name Bytes
+ * @description
+ * A Bytes wrapper for Vec<u8>. The significant difference between this and a normal Uint8Array
+ * is that this version allows for length-encoding. (i.e. it is a variable-item codec, the same
+ * as what is found in [[Text]] and [[Vec]])
+ */
+
+
+export class Bytes extends Raw {
+  constructor(registry, value) {
+    const [u8a, decodedLength] = decodeBytes(value);
+    super(registry, u8a, decodedLength);
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    return this.length + compactToU8a(this.length).length;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return 'Bytes';
+  }
+  /**
+   * @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) {
+    return isBare ? super.toU8a(isBare) : compactAddLength(this);
+  }
+
+}

package/extended/HashMap.cjs

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HashMap = void 0;
+
+var _Map = require("./Map.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+class HashMap extends _Map.CodecMap {
+  static with(keyType, valType) {
+    return class extends HashMap {
+      constructor(registry, value) {
+        super(registry, keyType, valType, value);
+      }
+
+    };
+  }
+
+}
+
+exports.HashMap = HashMap;

package/extended/HashMap.d.ts

@@ -0,0 +1,5 @@
+import type { Codec, CodecClass } from '../types';
+import { CodecMap } from './Map';
+export declare class HashMap<K extends Codec = Codec, V extends Codec = Codec> extends CodecMap<K, V> {
+    static with<K extends Codec, V extends Codec>(keyType: CodecClass<K> | string, valType: CodecClass<V> | string): CodecClass<CodecMap<K, V>>;
+}

package/extended/HashMap.js

@@ -0,0 +1,14 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { CodecMap } from "./Map.js";
+export class HashMap extends CodecMap {
+  static with(keyType, valType) {
+    return class extends HashMap {
+      constructor(registry, value) {
+        super(registry, keyType, valType, value);
+      }
+
+    };
+  }
+
+}

package/extended/Linkage.cjs

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LinkageResult = exports.Linkage = void 0;
+
+var _Option = require("../base/Option.cjs");
+
+var _Tuple = require("../base/Tuple.cjs");
+
+var _Vec = require("../base/Vec.cjs");
+
+var _Struct = require("../native/Struct.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+const EMPTY = new Uint8Array();
+/**
+ * @name Linkage
+ * @description The wrapper for the result from a LinkedMap
+ */
+
+class Linkage extends _Struct.Struct {
+  constructor(registry, Type, value) {
+    super(registry, {
+      previous: _Option.Option.with(Type),
+      // eslint-disable-next-line sort-keys
+      next: _Option.Option.with(Type)
+    }, value);
+  }
+
+  static withKey(Type) {
+    return class extends Linkage {
+      constructor(registry, value) {
+        super(registry, Type, value);
+      }
+
+    };
+  }
+
+  get previous() {
+    return this.get('previous');
+  }
+
+  get next() {
+    return this.get('next');
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `Linkage<${this.next.toRawType(true)}>`;
+  }
+  /**
+   * @description Custom toU8a which with bare mode does not return the linkage if empty
+   */
+
+
+  toU8a() {
+    // As part of a storage query (where these appear), in the case of empty, the values
+    // are NOT populated by the node - follow the same logic, leaving it empty
+    return this.isEmpty ? EMPTY : super.toU8a();
+  }
+
+}
+/**
+ * @name LinkageResult
+ * @description A Linkage keys/Values tuple
+ */
+
+
+exports.Linkage = Linkage;
+
+class LinkageResult extends _Tuple.Tuple {
+  constructor(registry, _ref, _ref2) {
+    let [TypeKey, keys] = _ref;
+    let [TypeValue, values] = _ref2;
+    super(registry, {
+      Keys: _Vec.Vec.with(TypeKey),
+      Values: _Vec.Vec.with(TypeValue)
+    }, [keys, values]);
+  }
+
+}
+
+exports.LinkageResult = LinkageResult;

package/extended/Linkage.d.ts

@@ -0,0 +1,31 @@
+import type { Codec, CodecClass, CodecRegistry } from '../types';
+import { Option } from '../base/Option';
+import { Tuple } from '../base/Tuple';
+import { Struct } from '../native/Struct';
+declare type TypeWithValues = [CodecClass, any[]];
+/**
+ * @name Linkage
+ * @description The wrapper for the result from a LinkedMap
+ */
+export declare class Linkage<T extends Codec> extends Struct {
+    constructor(registry: CodecRegistry, Type: CodecClass | string, value?: unknown);
+    static withKey<O extends Codec>(Type: CodecClass | string): CodecClass<Linkage<O>>;
+    get previous(): Option<T>;
+    get next(): Option<T>;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Custom toU8a which with bare mode does not return the linkage if empty
+     */
+    toU8a(): Uint8Array;
+}
+/**
+ * @name LinkageResult
+ * @description A Linkage keys/Values tuple
+ */
+export declare class LinkageResult extends Tuple {
+    constructor(registry: CodecRegistry, [TypeKey, keys]: TypeWithValues, [TypeValue, values]: TypeWithValues);
+}
+export {};

package/extended/Linkage.js

@@ -0,0 +1,71 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Option } from "../base/Option.js";
+import { Tuple } from "../base/Tuple.js";
+import { Vec } from "../base/Vec.js";
+import { Struct } from "../native/Struct.js";
+const EMPTY = new Uint8Array();
+/**
+ * @name Linkage
+ * @description The wrapper for the result from a LinkedMap
+ */
+
+export class Linkage extends Struct {
+  constructor(registry, Type, value) {
+    super(registry, {
+      previous: Option.with(Type),
+      // eslint-disable-next-line sort-keys
+      next: Option.with(Type)
+    }, value);
+  }
+
+  static withKey(Type) {
+    return class extends Linkage {
+      constructor(registry, value) {
+        super(registry, Type, value);
+      }
+
+    };
+  }
+
+  get previous() {
+    return this.get('previous');
+  }
+
+  get next() {
+    return this.get('next');
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `Linkage<${this.next.toRawType(true)}>`;
+  }
+  /**
+   * @description Custom toU8a which with bare mode does not return the linkage if empty
+   */
+
+
+  toU8a() {
+    // As part of a storage query (where these appear), in the case of empty, the values
+    // are NOT populated by the node - follow the same logic, leaving it empty
+    return this.isEmpty ? EMPTY : super.toU8a();
+  }
+
+}
+/**
+ * @name LinkageResult
+ * @description A Linkage keys/Values tuple
+ */
+
+export class LinkageResult extends Tuple {
+  constructor(registry, [TypeKey, keys], [TypeValue, values]) {
+    super(registry, {
+      Keys: Vec.with(TypeKey),
+      Values: Vec.with(TypeValue)
+    }, [keys, values]);
+  }
+
+}