@atomicfinance/bitcoin-dlc-provider 3.6.0 → 4.0.0

package/.yalc/@node-dlc/messaging/dist/messages/RoundingIntervals.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoundingIntervals = void 0;
+const bufio_1 = require("@node-dlc/bufio");
+const MessageType_1 = require("../MessageType");
+const util_1 = require("../util");
+/**
+ * RoundingIntervals defines rounding intervals for numeric outcome contracts.
+ * Updated to match dlcspecs format (no longer uses TLV).
+ */
+class RoundingIntervals {
+    constructor() {
+        /**
+         * The type for rounding_intervals message. rounding_intervals = 42788
+         */
+        this.type = RoundingIntervals.type;
+        this.intervals = [];
+    }
+    /**
+     * Creates a RoundingIntervals from JSON data
+     * @param json JSON object representing rounding intervals
+     */
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+    static fromJSON(json) {
+        const instance = new RoundingIntervals();
+        const intervals = json.intervals || [];
+        instance.intervals = intervals.map((interval) => ({
+            beginInterval: (0, util_1.toBigInt)(interval.beginInterval || interval.begin_interval),
+            roundingMod: (0, util_1.toBigInt)(interval.roundingMod || interval.rounding_mod),
+        }));
+        return instance;
+    }
+    /**
+     * Deserializes a rounding_intervals message
+     * @param buf
+     */
+    static deserialize(buf) {
+        const instance = new RoundingIntervals();
+        const reader = new bufio_1.BufferReader(buf);
+        const numRoundingIntervals = Number(reader.readBigSize());
+        for (let i = 0; i < numRoundingIntervals; i++) {
+            const beginInterval = reader.readUInt64BE();
+            const roundingMod = reader.readUInt64BE();
+            instance.intervals.push({ beginInterval, roundingMod });
+        }
+        return instance;
+    }
+    /**
+     * Validates correctness of all fields in the message
+     * https://github.com/discreetlogcontracts/dlcspecs/blob/master/NumericOutcome.md#requirements
+     * @throws Will throw an error if validation fails
+     */
+    validate() {
+        // 1. Intervals must be non-negative
+        for (const interval of this.intervals) {
+            if (interval.beginInterval < 0) {
+                throw new Error('beginInterval must be non-negative');
+            }
+        }
+        // 2. Intervals must be strictly increasing
+        for (let i = 1; i < this.intervals.length; ++i) {
+            if (this.intervals[i - 1].beginInterval >= this.intervals[i].beginInterval) {
+                throw new Error(`Intervals must be strictly increasing`);
+            }
+        }
+    }
+    /**
+     * Converts rounding_intervals to JSON
+     */
+    toJSON() {
+        return {
+            intervals: this.intervals.map((interval) => {
+                return {
+                    beginInterval: Number(interval.beginInterval),
+                    roundingMod: Number(interval.roundingMod),
+                };
+            }),
+        };
+    }
+    /**
+     * Serializes the rounding_intervals message into a Buffer
+     */
+    serialize() {
+        const writer = new bufio_1.BufferWriter();
+        writer.writeBigSize(this.intervals.length);
+        for (const interval of this.intervals) {
+            writer.writeUInt64BE(interval.beginInterval);
+            writer.writeUInt64BE(interval.roundingMod);
+        }
+        return writer.toBuffer();
+    }
+}
+exports.RoundingIntervals = RoundingIntervals;
+RoundingIntervals.type = MessageType_1.MessageType.RoundingIntervals;
+//# sourceMappingURL=RoundingIntervals.js.map

package/.yalc/@node-dlc/messaging/dist/messages/RoundingIntervals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoundingIntervals.js","sourceRoot":"","sources":["../../lib/messages/RoundingIntervals.ts"],"names":[],"mappings":"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"}

package/.yalc/@node-dlc/messaging/dist/messages/ScriptWitnessV0.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { BufferReader } from '@node-dlc/bufio';
+/**
+ * ScriptWitness is the data for a witness element in a witness stack.
+ * An empty witness_stack is an error, as every input must be Segwit.
+ * Witness elements should not include their length as part of the witness
+ * data.
+ */
+export declare class ScriptWitnessV0 {
+    /**
+     * Deserializes an script_witness_v0 message
+     * @param buf
+     */
+    static deserialize(buf: Buffer): ScriptWitnessV0;
+    static getWitness(reader: BufferReader): Buffer;
+    length: number;
+    witness: Buffer;
+    /**
+     * Converts script_witness_v0 to JSON
+     */
+    toJSON(): IScriptWitnessV0JSON;
+    /**
+     * Serializes the script_witness_v0 message into a Buffer
+     */
+    serialize(): Buffer;
+}
+export interface IScriptWitnessV0JSON {
+    witness: string;
+}

package/.yalc/@node-dlc/messaging/dist/messages/ScriptWitnessV0.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptWitnessV0 = void 0;
+const bufio_1 = require("@node-dlc/bufio");
+/**
+ * ScriptWitness is the data for a witness element in a witness stack.
+ * An empty witness_stack is an error, as every input must be Segwit.
+ * Witness elements should not include their length as part of the witness
+ * data.
+ */
+class ScriptWitnessV0 {
+    /**
+     * Deserializes an script_witness_v0 message
+     * @param buf
+     */
+    static deserialize(buf) {
+        const instance = new ScriptWitnessV0();
+        const reader = new bufio_1.BufferReader(buf);
+        instance.length = Number(reader.readBigSize());
+        instance.witness = reader.readBytes(instance.length);
+        return instance;
+    }
+    static getWitness(reader) {
+        const length = Number(reader.readBigSize());
+        const body = reader.readBytes(Number(length));
+        const writer = new bufio_1.BufferWriter();
+        writer.writeBigSize(length);
+        writer.writeBytes(body);
+        return writer.toBuffer();
+    }
+    /**
+     * Converts script_witness_v0 to JSON
+     */
+    toJSON() {
+        return {
+            witness: this.witness.toString('hex'),
+        };
+    }
+    /**
+     * Serializes the script_witness_v0 message into a Buffer
+     */
+    serialize() {
+        const writer = new bufio_1.BufferWriter();
+        writer.writeBigSize(this.witness.length);
+        writer.writeBytes(this.witness);
+        return writer.toBuffer();
+    }
+}
+exports.ScriptWitnessV0 = ScriptWitnessV0;
+//# sourceMappingURL=ScriptWitnessV0.js.map

package/.yalc/@node-dlc/messaging/dist/messages/ScriptWitnessV0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScriptWitnessV0.js","sourceRoot":"","sources":["../../lib/messages/ScriptWitnessV0.ts"],"names":[],"mappings":";;;AAAA,2CAA6D;AAE7D;;;;;GAKG;AACH,MAAa,eAAe;IAC1B;;;OAGG;IACI,MAAM,CAAC,WAAW,CAAC,GAAW;QACnC,MAAM,QAAQ,GAAG,IAAI,eAAe,EAAE,CAAC;QACvC,MAAM,MAAM,GAAG,IAAI,oBAAY,CAAC,GAAG,CAAC,CAAC;QAErC,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;QAC/C,QAAQ,CAAC,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAErD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEM,MAAM,CAAC,UAAU,CAAC,MAAoB;QAC3C,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;QAC5C,MAAM,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QAE9C,MAAM,MAAM,GAAG,IAAI,oBAAY,EAAE,CAAC;QAClC,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAC5B,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAExB,OAAO,MAAM,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAMD;;OAEG;IACI,MAAM;QACX,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;SACtC,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,SAAS;QACd,MAAM,MAAM,GAAG,IAAI,oBAAY,EAAE,CAAC;QAElC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACzC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAEhC,OAAO,MAAM,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;CACF;AAlDD,0CAkDC"}

package/.yalc/@node-dlc/messaging/dist/messages/Tlv.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+export declare class Tlv {
+    /**
+     * Deserializes an tlv message
+     * @param buf
+     */
+    static deserialize(buf: Buffer): Tlv;
+    type: number;
+    length: bigint;
+    body: Buffer;
+    /**
+     * Serializes the tlv message into a Buffer
+     */
+    serialize(): Buffer;
+}

package/.yalc/@node-dlc/messaging/dist/messages/Tlv.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tlv = void 0;
+const bufio_1 = require("@node-dlc/bufio");
+class Tlv {
+    /**
+     * Deserializes an tlv message
+     * @param buf
+     */
+    static deserialize(buf) {
+        const instance = new Tlv();
+        const reader = new bufio_1.BufferReader(buf);
+        instance.type = Number(reader.readBigSize()); // read type
+        instance.length = reader.readBigSize();
+        instance.body = reader.readBytes(Number(instance.length));
+        return instance;
+    }
+    /**
+     * Serializes the tlv message into a Buffer
+     */
+    serialize() {
+        const writer = new bufio_1.BufferWriter();
+        writer.writeBigSize(this.type);
+        const dataWriter = new bufio_1.BufferWriter();
+        dataWriter.writeBytes(this.body);
+        writer.writeBigSize(dataWriter.size);
+        writer.writeBytes(dataWriter.toBuffer());
+        return writer.toBuffer();
+    }
+}
+exports.Tlv = Tlv;
+//# sourceMappingURL=Tlv.js.map

package/.yalc/@node-dlc/messaging/dist/messages/Tlv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tlv.js","sourceRoot":"","sources":["../../lib/messages/Tlv.ts"],"names":[],"mappings":";;;AAAA,2CAA6D;AAE7D,MAAa,GAAG;IACd;;;OAGG;IACI,MAAM,CAAC,WAAW,CAAC,GAAW;QACnC,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAE,CAAC;QAC3B,MAAM,MAAM,GAAG,IAAI,oBAAY,CAAC,GAAG,CAAC,CAAC;QAErC,QAAQ,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,YAAY;QAC1D,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC;QACvC,QAAQ,CAAC,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;QAE1D,OAAO,QAAQ,CAAC;IAClB,CAAC;IAQD;;OAEG;IACI,SAAS;QACd,MAAM,MAAM,GAAG,IAAI,oBAAY,EAAE,CAAC;QAClC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/B,MAAM,UAAU,GAAG,IAAI,oBAAY,EAAE,CAAC;QAEtC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEjC,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACrC,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC;QAEzC,OAAO,MAAM,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;CACF;AArCD,kBAqCC"}

package/.yalc/@node-dlc/messaging/dist/serialize/F64.d.ts

@@ -0,0 +1,154 @@
+/// <reference types="node" />
+import Decimal from 'decimal.js';
+/**
+ * IEEE 754 double-precision floating-point number implementation
+ *
+ * Format: 1 bit sign + 11 bits exponent + 52 bits mantissa
+ *
+ * This class works directly with the binary representation to avoid
+ * precision loss when serializing/deserializing f64 values to/from buffers.
+ */
+export declare class F64 {
+    private _buffer;
+    /**
+     * Create an F64 from raw bytes (IEEE 754 format)
+     */
+    constructor(buffer?: Buffer);
+    /**
+     * Create F64 from JavaScript number
+     */
+    static fromNumber(num: number): F64;
+    /**
+     * Create F64 from Decimal.js value
+     * Uses the most precise conversion possible
+     */
+    static fromDecimal(decimal: Decimal): F64;
+    /**
+     * Create F64 from string representation
+     * Uses Decimal.js to parse the string without precision loss from JavaScript Number
+     */
+    static fromString(str: string): F64;
+    /**
+     * Create F64 from bigint (treating as integer value)
+     */
+    static fromBigInt(bigint: bigint): F64;
+    /**
+     * Create F64 representing zero (static method for API compatibility)
+     */
+    static zero(): F64;
+    /**
+     * Create F64 with specific IEEE 754 components
+     */
+    static fromComponents(sign: boolean, exponent: number, mantissa: bigint): F64;
+    /**
+     * Get the raw buffer containing IEEE 754 representation
+     */
+    getBuffer(): Buffer;
+    /**
+     * Serialize to buffer (big-endian)
+     */
+    serialize(): Buffer;
+    /**
+     * Deserialize from buffer (big-endian)
+     */
+    static deserialize(buffer: Buffer): F64;
+    /**
+     * Write to BufferWriter
+     */
+    writeTo(writer: any): void;
+    /**
+     * Read from BufferReader
+     */
+    static readFrom(reader: any): F64;
+    /**
+     * Convert to JavaScript number
+     * This may lose precision for very large or very precise values
+     */
+    toNumber(): number;
+    /**
+     * Convert to Decimal.js for arbitrary precision
+     */
+    toDecimal(): Decimal;
+    /**
+     * Extract IEEE 754 components
+     */
+    getComponents(): {
+        sign: boolean;
+        exponent: number;
+        mantissa: bigint;
+    };
+    /**
+     * Check if the value is finite
+     */
+    isFinite(): boolean;
+    /**
+     * Check if the value is NaN
+     */
+    isNaN(): boolean;
+    /**
+     * Check if the value is infinite
+     */
+    isInfinite(): boolean;
+    /**
+     * Check if the value is zero
+     */
+    isZero(): boolean;
+    /**
+     * Get string representation
+     */
+    toString(): string;
+    /**
+     * Convert to JSON-safe value: number if within safe range, string if too large
+     * This preserves precision for very large numbers that exceed JavaScript's MAX_SAFE_INTEGER
+     */
+    toJSONValue(): number | string;
+    /**
+     * Create F64 from JSON value (handles both number and string inputs)
+     */
+    static fromJSONValue(value: number | string): F64;
+    /**
+     * Get hex representation of the raw bytes
+     */
+    toHex(): string;
+    /**
+     * Create F64 from hex string
+     */
+    static fromHex(hex: string): F64;
+    /**
+     * Compare with another F64
+     */
+    equals(other: F64): boolean;
+    /**
+     * Equality comparison (alias for equals, for API compatibility)
+     */
+    eq(other: F64 | number): boolean;
+    /**
+     * Greater than comparison
+     */
+    gt(other: F64 | number): boolean;
+    /**
+     * Less than comparison
+     */
+    lt(other: F64 | number): boolean;
+    /**
+     * Greater than or equal comparison
+     */
+    gte(other: F64 | number): boolean;
+    /**
+     * Less than or equal comparison
+     */
+    lte(other: F64 | number): boolean;
+    /**
+     * Create a copy
+     */
+    clone(): F64;
+    /**
+     * Constants
+     */
+    static get ZERO(): F64;
+    static get ONE(): F64;
+    static get NEGATIVE_ONE(): F64;
+    static get INFINITY(): F64;
+    static get NEGATIVE_INFINITY(): F64;
+    static get NaN(): F64;
+}

package/.yalc/@node-dlc/messaging/dist/serialize/F64.js

@@ -0,0 +1,307 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.F64 = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+/**
+ * IEEE 754 double-precision floating-point number implementation
+ *
+ * Format: 1 bit sign + 11 bits exponent + 52 bits mantissa
+ *
+ * This class works directly with the binary representation to avoid
+ * precision loss when serializing/deserializing f64 values to/from buffers.
+ */
+class F64 {
+    /**
+     * Create an F64 from raw bytes (IEEE 754 format)
+     */
+    constructor(buffer) {
+        if (buffer) {
+            if (buffer.length !== 8) {
+                throw new Error('F64 buffer must be exactly 8 bytes');
+            }
+            this._buffer = Buffer.from(buffer);
+        }
+        else {
+            this._buffer = Buffer.alloc(8);
+        }
+    }
+    /**
+     * Create F64 from JavaScript number
+     */
+    static fromNumber(num) {
+        const buffer = Buffer.alloc(8);
+        buffer.writeDoubleBE(num, 0);
+        return new F64(buffer);
+    }
+    /**
+     * Create F64 from Decimal.js value
+     * Uses the most precise conversion possible
+     */
+    static fromDecimal(decimal) {
+        // Convert to number and let IEEE 754 handle the precision
+        const num = decimal.toNumber();
+        return F64.fromNumber(num);
+    }
+    /**
+     * Create F64 from string representation
+     * Uses Decimal.js to parse the string without precision loss from JavaScript Number
+     */
+    static fromString(str) {
+        // Parse string using Decimal.js to avoid JavaScript Number precision loss
+        const decimal = new decimal_js_1.default(str);
+        return F64.fromDecimal(decimal);
+    }
+    /**
+     * Create F64 from bigint (treating as integer value)
+     */
+    static fromBigInt(bigint) {
+        const num = Number(bigint);
+        return F64.fromNumber(num);
+    }
+    /**
+     * Create F64 representing zero (static method for API compatibility)
+     */
+    static zero() {
+        return F64.fromNumber(0);
+    }
+    /**
+     * Create F64 with specific IEEE 754 components
+     */
+    static fromComponents(sign, exponent, mantissa) {
+        if (exponent < 0 || exponent > 2047) {
+            throw new Error('Exponent must be between 0 and 2047');
+        }
+        if (mantissa < BigInt(0) || mantissa >= BigInt(1) << BigInt(52)) {
+            throw new Error('Mantissa must be between 0 and 2^52-1');
+        }
+        const buffer = Buffer.alloc(8);
+        // Pack into 64-bit big-endian format
+        // Bit layout: SEEEEEEE EEEEMMMM MMMMMMMM MMMMMMMM MMMMMMMM MMMMMMMM MMMMMMMM MMMMMMMM
+        const signBit = sign ? BigInt(1) : BigInt(0);
+        const expBits = BigInt(exponent);
+        const mantissaBits = mantissa;
+        const ieee754Bits = (signBit << BigInt(63)) | (expBits << BigInt(52)) | mantissaBits;
+        // Write as big-endian bytes
+        for (let i = 0; i < 8; i++) {
+            const byteValue = Number((ieee754Bits >> BigInt(56 - i * 8)) & BigInt(0xff));
+            buffer.writeUInt8(byteValue, i);
+        }
+        return new F64(buffer);
+    }
+    /**
+     * Get the raw buffer containing IEEE 754 representation
+     */
+    getBuffer() {
+        return Buffer.from(this._buffer);
+    }
+    /**
+     * Serialize to buffer (big-endian)
+     */
+    serialize() {
+        return this.getBuffer();
+    }
+    /**
+     * Deserialize from buffer (big-endian)
+     */
+    static deserialize(buffer) {
+        return new F64(buffer);
+    }
+    /**
+     * Write to BufferWriter
+     */
+    writeTo(writer) {
+        writer.writeBytes(this._buffer);
+    }
+    /**
+     * Read from BufferReader
+     */
+    static readFrom(reader) {
+        const buffer = reader.readBytes(8);
+        return new F64(buffer);
+    }
+    /**
+     * Convert to JavaScript number
+     * This may lose precision for very large or very precise values
+     */
+    toNumber() {
+        return this._buffer.readDoubleBE(0);
+    }
+    /**
+     * Convert to Decimal.js for arbitrary precision
+     */
+    toDecimal() {
+        return new decimal_js_1.default(this.toNumber());
+    }
+    /**
+     * Extract IEEE 754 components
+     */
+    getComponents() {
+        // Read as big-endian 64-bit integer
+        let ieee754Bits = BigInt(0);
+        for (let i = 0; i < 8; i++) {
+            ieee754Bits =
+                (ieee754Bits << BigInt(8)) | BigInt(this._buffer.readUInt8(i));
+        }
+        const sign = (ieee754Bits & (BigInt(1) << BigInt(63))) !== BigInt(0);
+        const exponent = Number((ieee754Bits >> BigInt(52)) & BigInt(0x7ff));
+        const mantissa = ieee754Bits & ((BigInt(1) << BigInt(52)) - BigInt(1));
+        return { sign, exponent, mantissa };
+    }
+    /**
+     * Check if the value is finite
+     */
+    isFinite() {
+        const { exponent } = this.getComponents();
+        return exponent !== 2047; // NaN and Infinity have exponent = 2047
+    }
+    /**
+     * Check if the value is NaN
+     */
+    isNaN() {
+        const { exponent, mantissa } = this.getComponents();
+        return exponent === 2047 && mantissa !== BigInt(0);
+    }
+    /**
+     * Check if the value is infinite
+     */
+    isInfinite() {
+        const { exponent, mantissa } = this.getComponents();
+        return exponent === 2047 && mantissa === BigInt(0);
+    }
+    /**
+     * Check if the value is zero
+     */
+    isZero() {
+        const { exponent, mantissa } = this.getComponents();
+        return exponent === 0 && mantissa === BigInt(0);
+    }
+    /**
+     * Get string representation
+     */
+    toString() {
+        return this.toNumber().toString();
+    }
+    /**
+     * Convert to JSON-safe value: number if within safe range, string if too large
+     * This preserves precision for very large numbers that exceed JavaScript's MAX_SAFE_INTEGER
+     */
+    toJSONValue() {
+        const num = this.toNumber();
+        // Check if the number is within JavaScript's safe integer range
+        if (num <= Number.MAX_SAFE_INTEGER && num >= Number.MIN_SAFE_INTEGER) {
+            return num;
+        }
+        // For very large numbers, return as string to preserve precision
+        return num.toString();
+    }
+    /**
+     * Create F64 from JSON value (handles both number and string inputs)
+     */
+    static fromJSONValue(value) {
+        if (typeof value === 'string') {
+            return F64.fromString(value);
+        }
+        else {
+            return F64.fromNumber(value);
+        }
+    }
+    /**
+     * Get hex representation of the raw bytes
+     */
+    toHex() {
+        return this._buffer.toString('hex');
+    }
+    /**
+     * Create F64 from hex string
+     */
+    static fromHex(hex) {
+        const buffer = Buffer.from(hex, 'hex');
+        if (buffer.length !== 8) {
+            throw new Error('Hex string must represent exactly 8 bytes');
+        }
+        return new F64(buffer);
+    }
+    /**
+     * Compare with another F64
+     */
+    equals(other) {
+        return this._buffer.equals(other._buffer);
+    }
+    /**
+     * Equality comparison (alias for equals, for API compatibility)
+     */
+    eq(other) {
+        if (typeof other === 'number') {
+            return this.toNumber() === other;
+        }
+        return this.equals(other);
+    }
+    /**
+     * Greater than comparison
+     */
+    gt(other) {
+        if (typeof other === 'number') {
+            return this.toNumber() > other;
+        }
+        return this.toNumber() > other.toNumber();
+    }
+    /**
+     * Less than comparison
+     */
+    lt(other) {
+        if (typeof other === 'number') {
+            return this.toNumber() < other;
+        }
+        return this.toNumber() < other.toNumber();
+    }
+    /**
+     * Greater than or equal comparison
+     */
+    gte(other) {
+        if (typeof other === 'number') {
+            return this.toNumber() >= other;
+        }
+        return this.toNumber() >= other.toNumber();
+    }
+    /**
+     * Less than or equal comparison
+     */
+    lte(other) {
+        if (typeof other === 'number') {
+            return this.toNumber() <= other;
+        }
+        return this.toNumber() <= other.toNumber();
+    }
+    /**
+     * Create a copy
+     */
+    clone() {
+        return new F64(this._buffer);
+    }
+    /**
+     * Constants
+     */
+    static get ZERO() {
+        return F64.fromNumber(0);
+    }
+    static get ONE() {
+        return F64.fromNumber(1);
+    }
+    static get NEGATIVE_ONE() {
+        return F64.fromNumber(-1);
+    }
+    static get INFINITY() {
+        return F64.fromNumber(Number.POSITIVE_INFINITY);
+    }
+    static get NEGATIVE_INFINITY() {
+        return F64.fromNumber(Number.NEGATIVE_INFINITY);
+    }
+    static get NaN() {
+        return F64.fromNumber(Number.NaN);
+    }
+}
+exports.F64 = F64;
+//# sourceMappingURL=F64.js.map