@polkadot/types-codec 8.9.2-0 → 8.9.2-11

package/abstract/Array.d.ts

@@ -10,6 +10,11 @@ import type { AnyJson, Codec, Inspect, IU8a, IVec, Registry } from '../types';
 export declare abstract class AbstractArray<T extends Codec> extends Array<T> implements IVec<T> {
     readonly registry: Registry;
     createdAtHash?: IU8a;
+    /**
+     * @description This ensures that operators such as clice, filter, map, etc. return
+     * new Array instances (without this we need to apply overrides)
+     */
+    static get [Symbol.species](): typeof Array;
     protected constructor(registry: Registry, length: number);
     /**
      * @description The length of the value when encoded as a Uint8Array
@@ -66,24 +71,4 @@ export declare abstract class AbstractArray<T extends Codec> extends Array<T> im
      */
     toU8a(isBare?: boolean): Uint8Array;
     toU8aInner(isBare?: boolean): Uint8Array[];
-    /**
-     * @description Concatenates two arrays
-     */
-    concat(other: T[]): T[];
-    /**
-     * @description Filters the array with the callback
-     */
-    filter(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: unknown): T[];
-    /**
-     * @description Maps the array with the callback
-     */
-    map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: unknown): U[];
-    /**
-     * @description Checks if the array includes a specific value
-     */
-    includes(check: unknown): boolean;
-    /**
-     * @description Returns a slice of an array
-     */
-    slice(start?: number, end?: number): T[];
 }

package/abstract/Array.js

@@ -11,6 +11,14 @@ import { compareArray } from "../utils/compareArray.js";
  */
 
 export class AbstractArray extends Array {
+  /**
+   * @description This ensures that operators such as clice, filter, map, etc. return
+   * new Array instances (without this we need to apply overrides)
+   */
+  static get [Symbol.species]() {
+    return Array;
+  }
+
   constructor(registry, length) {
     super(length);
     this.registry = registry;
@@ -165,49 +173,6 @@ export class AbstractArray extends Array {
     }
 
     return encoded;
-  } // Below are methods that we override. When we do a `new Vec(...).map()`,
-  // we want it to return an Array. We only override the methods that return a
-  // new instance.
-
-  /**
-   * @description Concatenates two arrays
-   */
-
-
-  concat(other) {
-    return this.toArray().concat(other instanceof AbstractArray ? other.toArray() : other);
-  }
-  /**
-   * @description Filters the array with the callback
-   */
-
-
-  filter(callbackfn, thisArg) {
-    return this.toArray().filter(callbackfn, thisArg);
-  }
-  /**
-   * @description Maps the array with the callback
-   */
-
-
-  map(callbackfn, thisArg) {
-    return this.toArray().map(callbackfn, thisArg);
-  }
-  /**
-   * @description Checks if the array includes a specific value
-   */
-
-
-  includes(check) {
-    return this.some(value => value.eq(check));
-  }
-  /**
-   * @description Returns a slice of an array
-   */
-
-
-  slice(start, end) {
-    return this.toArray().slice(start, end);
   }
 
 }

package/abstract/BigInt.d.ts

@@ -0,0 +1,4 @@
+import { BigInt } from '@polkadot/x-bigint';
+export declare abstract class AbstractBigInt extends BigInt {
+    constructor(value: string | number | bigint | boolean);
+}

package/abstract/BigInt.js

@@ -0,0 +1,13 @@
+// Copyright 2017-2022 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { BigInt } from '@polkadot/x-bigint'; // @ts-expect-error not extensible, we make it extensible here
+
+export class AbstractBigInt extends BigInt {
+  // @ts-expect-error super() not required, the self magic does that
+  constructor(value) {
+    const self = Object(BigInt(value));
+    Object.setPrototypeOf(self, AbstractBigInt.prototype);
+    return self;
+  }
+
+}

package/cjs/abstract/Array.js

@@ -20,6 +20,14 @@ var _compareArray = require("../utils/compareArray");
  * @noInheritDoc
  */
 class AbstractArray extends Array {
+  /**
+   * @description This ensures that operators such as clice, filter, map, etc. return
+   * new Array instances (without this we need to apply overrides)
+   */
+  static get [Symbol.species]() {
+    return Array;
+  }
+
   constructor(registry, length) {
     super(length);
     this.registry = registry;
@@ -174,49 +182,6 @@ class AbstractArray extends Array {
     }
 
     return encoded;
-  } // Below are methods that we override. When we do a `new Vec(...).map()`,
-  // we want it to return an Array. We only override the methods that return a
-  // new instance.
-
-  /**
-   * @description Concatenates two arrays
-   */
-
-
-  concat(other) {
-    return this.toArray().concat(other instanceof AbstractArray ? other.toArray() : other);
-  }
-  /**
-   * @description Filters the array with the callback
-   */
-
-
-  filter(callbackfn, thisArg) {
-    return this.toArray().filter(callbackfn, thisArg);
-  }
-  /**
-   * @description Maps the array with the callback
-   */
-
-
-  map(callbackfn, thisArg) {
-    return this.toArray().map(callbackfn, thisArg);
-  }
-  /**
-   * @description Checks if the array includes a specific value
-   */
-
-
-  includes(check) {
-    return this.some(value => value.eq(check));
-  }
-  /**
-   * @description Returns a slice of an array
-   */
-
-
-  slice(start, end) {
-    return this.toArray().slice(start, end);
   }
 
 }

package/cjs/abstract/BigInt.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AbstractBigInt = void 0;
+
+var _xBigint = require("@polkadot/x-bigint");
+
+// Copyright 2017-2022 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// @ts-expect-error not extensible, we make it extensible here
+class AbstractBigInt extends _xBigint.BigInt {
+  // @ts-expect-error super() not required, the self magic does that
+  constructor(value) {
+    const self = Object((0, _xBigint.BigInt)(value));
+    Object.setPrototypeOf(self, AbstractBigInt.prototype);
+    return self;
+  }
+
+}
+
+exports.AbstractBigInt = AbstractBigInt;

package/cjs/native/Float.js

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Float = void 0;
+
+var _util = require("@polkadot/util");
+
+// Copyright 2017-2022 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name Float
+ * @description
+ * A Codec wrapper for F32 & F64 values. You generally don't want to be using
+ * f32/f64 in your runtime, operations on fixed points numbers are preferable. This class
+ * was explicitly added since scale-codec has a flag that enables this and it is available
+ * in some eth_* RPCs
+ */
+class Float extends Number {
+  #bitLength;
+
+  constructor(registry, value) {
+    let {
+      bitLength = 32
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    super((0, _util.isU8a)(value) || (0, _util.isHex)(value) ? value.length === 0 ? 0 : (0, _util.u8aToFloat)((0, _util.u8aToU8a)(value), {
+      bitLength
+    }) : value || 0);
+    this.#bitLength = bitLength;
+    this.encodedLength = bitLength / 8;
+    this.initialU8aLength = this.encodedLength;
+    this.registry = registry;
+  }
+
+  static with(bitLength) {
+    return class extends Float {
+      constructor(registry, value) {
+        super(registry, value, {
+          bitLength
+        });
+      }
+
+    };
+  }
+  /**
+   * @description returns a hash of the contents
+   */
+
+
+  get hash() {
+    return this.registry.hash(this.toU8a());
+  }
+  /**
+   * @description Returns true if the type wraps an empty/default all-0 value
+   */
+
+
+  get isEmpty() {
+    return this.valueOf() === 0;
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    return this.valueOf() === Number(other);
+  }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {
+      outer: [this.toU8a()]
+    };
+  }
+  /**
+   * @description Returns a hex string representation of the value
+   */
+
+
+  toHex() {
+    return (0, _util.u8aToHex)(this.toU8a());
+  }
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+
+
+  toHuman() {
+    return this.toString();
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+
+
+  toJSON() {
+    // Not sure if this is actually a hex or a string value
+    // (would need to check against RPCs to see the result here)
+    return this.toHex();
+  }
+  /**
+   * @description Returns the number representation (Same as valueOf)
+   */
+
+
+  toNumber() {
+    return this.valueOf();
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `f${this.#bitLength}`;
+  }
+  /**
+   * @description Encodes the value as a Uint8Array as per the SCALE specifications
+   */
+
+
+  toU8a() {
+    return (0, _util.floatToU8a)(this, {
+      bitLength: this.#bitLength
+    });
+  }
+
+}
+
+exports.Float = Float;

package/cjs/native/Json.js

@@ -68,6 +68,10 @@ class Json extends Map {
   eq(other) {
     return (0, _utils.compareMap)(this, other);
   }
+  /**
+   * @description Returns a typed value from the internal map
+   */
+
 
   getT(key) {
     return this.get(key);

package/cjs/native/Raw.js

@@ -20,6 +20,14 @@ var _util = require("@polkadot/util");
  * @noInheritDoc
  */
 class Raw extends Uint8Array {
+  /**
+   * @description This ensures that operators such as clice, filter, map, etc. return
+   * new Array instances (without this we need to apply overrides)
+   */
+  static get [Symbol.species]() {
+    return Uint8Array;
+  }
+
   constructor(registry, value, initialU8aLength) {
     super((0, _util.u8aToU8a)(value));
     this.registry = registry;
@@ -65,15 +73,6 @@ class Raw extends Uint8Array {
   get isUtf8() {
     return (0, _util.isUtf8)(this);
   }
-  /**
-   * @description The length of the value
-   */
-
-
-  get length() {
-    // only included here since we ignore inherited docs
-    return super.length;
-  }
   /**
    * @description Returns the number of bits in the value
    */
@@ -104,28 +103,6 @@ class Raw extends Uint8Array {
       outer: [this.toU8a()]
     };
   }
-  /**
-   * @description Create a new slice from the actual buffer. (compat)
-   * @param start The position to start at
-   * @param end The position to end at
-   */
-
-
-  slice(start, end) {
-    // Like subarray below, we have to follow this approach since we are extending the TypeArray.
-    // This happens especially when it comes to further extensions, the length may be an override
-    return Uint8Array.from(this).slice(start, end);
-  }
-  /**
-   * @description Create a new subarray from the actual buffer. (compat)
-   * @param begin The position to start at
-   * @param end The position to end at
-   */
-
-
-  subarray(begin, end) {
-    return Uint8Array.from(this).subarray(begin, end);
-  }
   /**
    * @description Returns a hex string representation of the value
    */

package/cjs/native/index.js

@@ -27,6 +27,12 @@ Object.defineProperty(exports, "Date", {
     return _Date.CodecDate;
   }
 });
+Object.defineProperty(exports, "Float", {
+  enumerable: true,
+  get: function () {
+    return _Float.Float;
+  }
+});
 Object.defineProperty(exports, "Json", {
   enumerable: true,
   get: function () {
@@ -68,6 +74,8 @@ var _Bool = require("./Bool");
 
 var _Date = require("./Date");
 
+var _Float = require("./Float");
+
 var _Json = require("./Json");
 
 var _Raw = require("./Raw");

package/cjs/packageInfo.js

@@ -11,6 +11,6 @@ const packageInfo = {
   name: '@polkadot/types-codec',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '8.9.2-0'
+  version: '8.9.2-11'
 };
 exports.packageInfo = packageInfo;

package/cjs/primitive/F32.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.f32 = void 0;
+
+var _Float = require("../native/Float");
+
+// Copyright 2017-2022 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name f32
+ * @description
+ * A 32-bit float
+ */
+class f32 extends _Float.Float.with(32) {
+  // NOTE without this, we cannot properly determine extensions
+  __FloatType = 'f32';
+}
+
+exports.f32 = f32;

package/cjs/primitive/F64.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.f64 = void 0;
+
+var _Float = require("../native/Float");
+
+// Copyright 2017-2022 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name f64
+ * @description
+ * A 64-bit float
+ */
+class f64 extends _Float.Float.with(64) {
+  // NOTE without this, we cannot properly determine extensions
+  __FloatType = 'f64';
+}
+
+exports.f64 = f64;

package/cjs/primitive/index.js

@@ -3,6 +3,18 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "F32", {
+  enumerable: true,
+  get: function () {
+    return _F.f32;
+  }
+});
+Object.defineProperty(exports, "F64", {
+  enumerable: true,
+  get: function () {
+    return _F2.f64;
+  }
+});
 Object.defineProperty(exports, "I128", {
   enumerable: true,
   get: function () {
@@ -81,6 +93,18 @@ Object.defineProperty(exports, "USize", {
     return _USize.usize;
   }
 });
+Object.defineProperty(exports, "f32", {
+  enumerable: true,
+  get: function () {
+    return _F.f32;
+  }
+});
+Object.defineProperty(exports, "f64", {
+  enumerable: true,
+  get: function () {
+    return _F2.f64;
+  }
+});
 Object.defineProperty(exports, "i128", {
   enumerable: true,
   get: function () {
@@ -160,6 +184,10 @@ Object.defineProperty(exports, "usize", {
   }
 });
 
+var _F = require("./F32");
+
+var _F2 = require("./F64");
+
 var _I = require("./I8");
 
 var _I2 = require("./I16");

package/mod.d.ts

@@ -0,0 +1 @@
+export * from './index';

package/mod.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2022 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index';

package/native/Float.d.ts

@@ -0,0 +1,63 @@
+import type { HexString } from '@polkadot/util/types';
+import type { AnyFloat, CodecClass, IFloat, Inspect, IU8a, Registry } from '../types';
+interface Options {
+    bitLength?: 32 | 64;
+}
+/**
+ * @name Float
+ * @description
+ * A Codec wrapper for F32 & F64 values. You generally don't want to be using
+ * f32/f64 in your runtime, operations on fixed points numbers are preferable. This class
+ * was explicitly added since scale-codec has a flag that enables this and it is available
+ * in some eth_* RPCs
+ */
+export declare class Float extends Number implements IFloat {
+    #private;
+    createdAtHash?: IU8a;
+    readonly encodedLength: number;
+    readonly initialU8aLength?: number;
+    readonly registry: Registry;
+    constructor(registry: Registry, value?: AnyFloat, { bitLength }?: Options);
+    static with(bitLength: 32 | 64): CodecClass<Float>;
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash(): IU8a;
+    /**
+     * @description Returns true if the type wraps an empty/default all-0 value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    /**
+     * @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(): string;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): string;
+    /**
+     * @description Returns the number representation (Same as valueOf)
+     */
+    toNumber(): 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
+     */
+    toU8a(): Uint8Array;
+}
+export {};

package/native/Float.js

@@ -0,0 +1,125 @@
+// Copyright 2017-2022 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { floatToU8a, isHex, isU8a, u8aToFloat, u8aToHex, u8aToU8a } from '@polkadot/util';
+
+/**
+ * @name Float
+ * @description
+ * A Codec wrapper for F32 & F64 values. You generally don't want to be using
+ * f32/f64 in your runtime, operations on fixed points numbers are preferable. This class
+ * was explicitly added since scale-codec has a flag that enables this and it is available
+ * in some eth_* RPCs
+ */
+export class Float extends Number {
+  #bitLength;
+
+  constructor(registry, value, {
+    bitLength = 32
+  } = {}) {
+    super(isU8a(value) || isHex(value) ? value.length === 0 ? 0 : u8aToFloat(u8aToU8a(value), {
+      bitLength
+    }) : value || 0);
+    this.#bitLength = bitLength;
+    this.encodedLength = bitLength / 8;
+    this.initialU8aLength = this.encodedLength;
+    this.registry = registry;
+  }
+
+  static with(bitLength) {
+    return class extends Float {
+      constructor(registry, value) {
+        super(registry, value, {
+          bitLength
+        });
+      }
+
+    };
+  }
+  /**
+   * @description returns a hash of the contents
+   */
+
+
+  get hash() {
+    return this.registry.hash(this.toU8a());
+  }
+  /**
+   * @description Returns true if the type wraps an empty/default all-0 value
+   */
+
+
+  get isEmpty() {
+    return this.valueOf() === 0;
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    return this.valueOf() === Number(other);
+  }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {
+      outer: [this.toU8a()]
+    };
+  }
+  /**
+   * @description Returns a hex string representation of the value
+   */
+
+
+  toHex() {
+    return u8aToHex(this.toU8a());
+  }
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+
+
+  toHuman() {
+    return this.toString();
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+
+
+  toJSON() {
+    // Not sure if this is actually a hex or a string value
+    // (would need to check against RPCs to see the result here)
+    return this.toHex();
+  }
+  /**
+   * @description Returns the number representation (Same as valueOf)
+   */
+
+
+  toNumber() {
+    return this.valueOf();
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `f${this.#bitLength}`;
+  }
+  /**
+   * @description Encodes the value as a Uint8Array as per the SCALE specifications
+   */
+
+
+  toU8a() {
+    return floatToU8a(this, {
+      bitLength: this.#bitLength
+    });
+  }
+
+}

package/native/Json.d.ts

@@ -28,6 +28,9 @@ export declare class Json extends Map<string, any> implements Codec {
      * @description Compares the value of the input to see if there is a match
      */
     eq(other?: unknown): boolean;
+    /**
+     * @description Returns a typed value from the internal map
+     */
     getT<T>(key: string): T;
     /**
      * @description Unimplemented, will throw

package/native/Json.js

@@ -56,6 +56,10 @@ export class Json extends Map {
   eq(other) {
     return compareMap(this, other);
   }
+  /**
+   * @description Returns a typed value from the internal map
+   */
+
 
   getT(key) {
     return this.get(key);

package/native/Raw.d.ts

@@ -13,6 +13,11 @@ export declare class Raw extends Uint8Array implements IU8a {
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
     readonly registry: Registry;
+    /**
+     * @description This ensures that operators such as clice, filter, map, etc. return
+     * new Array instances (without this we need to apply overrides)
+     */
+    static get [Symbol.species](): typeof Uint8Array;
     constructor(registry: Registry, value?: AnyU8a, initialU8aLength?: number);
     /**
      * @description The length of the value when encoded as a Uint8Array
@@ -34,10 +39,6 @@ export declare class Raw extends Uint8Array implements IU8a {
      * @description Returns true if the wrapped value contains only utf8 characters
      */
     get isUtf8(): boolean;
-    /**
-     * @description The length of the value
-     */
-    get length(): number;
     /**
      * @description Returns the number of bits in the value
      */
@@ -50,18 +51,6 @@ export declare class Raw extends Uint8Array implements IU8a {
      * @description Returns a breakdown of the hex encoding for this Codec
      */
     inspect(): Inspect;
-    /**
-     * @description Create a new slice from the actual buffer. (compat)
-     * @param start The position to start at
-     * @param end The position to end at
-     */
-    slice(start?: number, end?: number): Uint8Array;
-    /**
-     * @description Create a new subarray from the actual buffer. (compat)
-     * @param begin The position to start at
-     * @param end The position to end at
-     */
-    subarray(begin?: number, end?: number): Uint8Array;
     /**
      * @description Returns a hex string representation of the value
      */

package/native/Raw.js

@@ -12,6 +12,14 @@ import { isAscii, isUndefined, isUtf8, u8aToHex, u8aToString, u8aToU8a } from '@
  */
 
 export class Raw extends Uint8Array {
+  /**
+   * @description This ensures that operators such as clice, filter, map, etc. return
+   * new Array instances (without this we need to apply overrides)
+   */
+  static get [Symbol.species]() {
+    return Uint8Array;
+  }
+
   constructor(registry, value, initialU8aLength) {
     super(u8aToU8a(value));
     this.registry = registry;
@@ -57,15 +65,6 @@ export class Raw extends Uint8Array {
   get isUtf8() {
     return isUtf8(this);
   }
-  /**
-   * @description The length of the value
-   */
-
-
-  get length() {
-    // only included here since we ignore inherited docs
-    return super.length;
-  }
   /**
    * @description Returns the number of bits in the value
    */
@@ -96,28 +95,6 @@ export class Raw extends Uint8Array {
       outer: [this.toU8a()]
     };
   }
-  /**
-   * @description Create a new slice from the actual buffer. (compat)
-   * @param start The position to start at
-   * @param end The position to end at
-   */
-
-
-  slice(start, end) {
-    // Like subarray below, we have to follow this approach since we are extending the TypeArray.
-    // This happens especially when it comes to further extensions, the length may be an override
-    return Uint8Array.from(this).slice(start, end);
-  }
-  /**
-   * @description Create a new subarray from the actual buffer. (compat)
-   * @param begin The position to start at
-   * @param end The position to end at
-   */
-
-
-  subarray(begin, end) {
-    return Uint8Array.from(this).subarray(begin, end);
-  }
   /**
    * @description Returns a hex string representation of the value
    */

package/native/index.d.ts

@@ -1,5 +1,6 @@
 export { bool, bool as Bool } from './Bool';
 export { CodecDate, CodecDate as Date } from './Date';
+export { Float } from './Float';
 export { Json } from './Json';
 export { Raw } from './Raw';
 export { CodecSet, CodecSet as Set } from './Set';

package/native/index.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 export { bool, bool as Bool } from "./Bool.js";
 export { CodecDate, CodecDate as Date } from "./Date.js";
+export { Float } from "./Float.js";
 export { Json } from "./Json.js";
 export { Raw } from "./Raw.js";
 export { CodecSet, CodecSet as Set } from "./Set.js";

package/package.json

@@ -20,7 +20,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "8.9.2-0",
+  "version": "8.9.2-11",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -47,6 +47,11 @@
       "require": "./cjs/abstract/Base.js",
       "default": "./abstract/Base.js"
     },
+    "./abstract/BigInt": {
+      "types": "./abstract/BigInt.d.ts",
+      "require": "./cjs/abstract/BigInt.js",
+      "default": "./abstract/BigInt.js"
+    },
     "./abstract/Int": {
       "types": "./abstract/Int.d.ts",
       "require": "./cjs/abstract/Int.js",
@@ -207,6 +212,8 @@
       "require": "./cjs/extended/WrapperOpaque.js",
       "default": "./extended/WrapperOpaque.js"
     },
+    "./mod.d.ts": "./mod.d.ts",
+    "./mod.ts": "./mod.ts",
     "./native": {
       "types": "./native/index.d.ts",
       "require": "./cjs/native/index.js",
@@ -222,6 +229,11 @@
       "require": "./cjs/native/Date.js",
       "default": "./native/Date.js"
     },
+    "./native/Float": {
+      "types": "./native/Float.d.ts",
+      "require": "./cjs/native/Float.js",
+      "default": "./native/Float.js"
+    },
     "./native/Json": {
       "types": "./native/Json.d.ts",
       "require": "./cjs/native/Json.js",
@@ -267,6 +279,16 @@
       "require": "./cjs/primitive/index.js",
       "default": "./primitive/index.js"
     },
+    "./primitive/F32": {
+      "types": "./primitive/F32.d.ts",
+      "require": "./cjs/primitive/F32.js",
+      "default": "./primitive/F32.js"
+    },
+    "./primitive/F64": {
+      "types": "./primitive/F64.d.ts",
+      "require": "./cjs/primitive/F64.js",
+      "default": "./primitive/F64.js"
+    },
     "./primitive/I128": {
       "types": "./primitive/I128.d.ts",
       "require": "./cjs/primitive/I128.js",
@@ -415,6 +437,7 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.18.3",
-    "@polkadot/util": "^9.5.1"
+    "@polkadot/util": "^9.5.2-18",
+    "@polkadot/x-bigint": "^9.5.2-18"
   }
 }

package/packageInfo.js

@@ -5,5 +5,5 @@ export const packageInfo = {
   name: '@polkadot/types-codec',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '8.9.2-0'
+  version: '8.9.2-11'
 };

package/primitive/F32.d.ts

@@ -0,0 +1,11 @@
+import { Float } from '../native/Float';
+declare const f32_base: import("../types").CodecClass<Float>;
+/**
+ * @name f32
+ * @description
+ * A 32-bit float
+ */
+export declare class f32 extends f32_base {
+    readonly __FloatType = "f32";
+}
+export {};

package/primitive/F32.js

@@ -0,0 +1,13 @@
+// Copyright 2017-2022 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Float } from "../native/Float.js";
+/**
+ * @name f32
+ * @description
+ * A 32-bit float
+ */
+
+export class f32 extends Float.with(32) {
+  // NOTE without this, we cannot properly determine extensions
+  __FloatType = 'f32';
+}

package/primitive/F64.d.ts

@@ -0,0 +1,11 @@
+import { Float } from '../native/Float';
+declare const f64_base: import("../types").CodecClass<Float>;
+/**
+ * @name f64
+ * @description
+ * A 64-bit float
+ */
+export declare class f64 extends f64_base {
+    readonly __FloatType = "f64";
+}
+export {};

package/primitive/F64.js

@@ -0,0 +1,13 @@
+// Copyright 2017-2022 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Float } from "../native/Float.js";
+/**
+ * @name f64
+ * @description
+ * A 64-bit float
+ */
+
+export class f64 extends Float.with(64) {
+  // NOTE without this, we cannot properly determine extensions
+  __FloatType = 'f64';
+}

package/primitive/index.d.ts

@@ -1,3 +1,5 @@
+export { f32, f32 as F32 } from './F32';
+export { f64, f64 as F64 } from './F64';
 export { i8, i8 as I8 } from './I8';
 export { i16, i16 as I16 } from './I16';
 export { i32, i32 as I32 } from './I32';

package/primitive/index.js

@@ -1,5 +1,7 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+export { f32, f32 as F32 } from "./F32.js";
+export { f64, f64 as F64 } from "./F64.js";
 export { i8, i8 as I8 } from "./I8.js";
 export { i16, i16 as I16 } from "./I16.js";
 export { i32, i32 as I32 } from "./I32.js";

package/types/helpers.d.ts

@@ -6,6 +6,7 @@ export declare type AnyJson = string | number | boolean | null | undefined | Any
 };
 export declare type AnyFunction = (...args: any[]) => any;
 export declare type AnyNumber = BN | bigint | Uint8Array | number | string;
+export declare type AnyFloat = Number | number | Uint8Array | string;
 export declare type AnyString = String | string;
 export declare type AnyBool = Boolean | boolean;
 export declare type AnyTuple = Codec[];

package/types/interfaces.d.ts

@@ -25,6 +25,9 @@ export interface INumber extends Codec {
     toBn(): BN;
     toNumber(): number;
 }
+export interface IFloat extends Codec {
+    toNumber(): number;
+}
 export interface IOption<T extends Codec = Codec> extends Codec {
     readonly isNone: boolean;
     readonly isSome: boolean;