@polkadot/types-codec 8.9.2-9 → 8.11.2

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/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-9'
+  version: '8.11.2'
 };
 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/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/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-9",
+  "version": "8.11.2",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -213,7 +213,6 @@
       "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",
@@ -229,6 +228,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",
@@ -274,6 +278,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",
@@ -421,8 +435,8 @@
     }
   },
   "dependencies": {
-    "@babel/runtime": "^7.18.3",
-    "@polkadot/util": "^9.5.2-15",
-    "@polkadot/x-bigint": "^9.5.2-15"
+    "@babel/runtime": "^7.18.6",
+    "@polkadot/util": "^9.7.2",
+    "@polkadot/x-bigint": "^9.7.2"
   }
 }

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-9'
+  version: '8.11.2'
 };

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;

package/mod.ts

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