@geoprotocol/grc-20 0.3.1 → 0.4.1

package/dist/test/basic.test.js

@@ -1,5 +1,7 @@
 import { describe, it, expect } from "vitest";
-import { EditBuilder, createEdit, createEntity, createRelation, updateEntity, deleteEntity, restoreEntity, updateRelation, deleteRelation, restoreRelation, createValueRef, encodeEdit, decodeEdit, encodeEditCompressed, decodeEditCompressed, encodeEditAuto, decodeEditAuto, isCompressed, preloadCompression, isCompressionReady, parseId, formatId, formatIdHex, randomId, derivedUuid, derivedUuidFromString, uniqueRelationId, relationEntityId, properties, types, relationTypes, languages, idsEqual, Reader, } from "../index.js";
+import { EditBuilder, createEdit, createEntity, createRelation, updateEntity, deleteEntity, restoreEntity, updateRelation, deleteRelation, restoreRelation, createValueRef, encodeEdit, decodeEdit, encodeEditCompressed, decodeEditCompressed, encodeEditAuto, decodeEditAuto, isCompressed, preloadCompression, isCompressionReady, parseId, formatId, randomId, derivedUuid, derivedUuidFromString, uniqueRelationId, relationEntityId, properties, types, relationTypes, languages, idsEqual, Reader, Writer, } from "../index.js";
+import { decodeValuePayload, encodeValuePayload } from "../codec/value.js";
+import { DataType } from "../types/value.js";
 function readObjectIds(encoded) {
     const reader = new Reader(encoded);
     reader.readBytes(4);
@@ -20,21 +22,40 @@ function readObjectIds(encoded) {
     reader.readIdVec(); // context IDs
     return objects;
 }
+function positiveBigIntToMinimalTwosComplement(value) {
+    let hex = value.toString(16);
+    if (hex.length % 2 !== 0) {
+        hex = `0${hex}`;
+    }
+    const raw = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < raw.length; i++) {
+        raw[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    if (raw.length === 0) {
+        return new Uint8Array([0]);
+    }
+    if ((raw[0] & 0x80) === 0) {
+        return raw;
+    }
+    const bytes = new Uint8Array(raw.length + 1);
+    bytes.set(raw, 1);
+    return bytes;
+}
 describe("ID utilities", () => {
-    it("formatId produces Base58 string", () => {
+    it("formatId produces 32 hex chars", () => {
         const id = randomId();
-        const b58 = formatId(id);
-        expect(b58.length).toBeLessThanOrEqual(22);
-        expect(/^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]+$/.test(b58)).toBe(true);
+        const hex = formatId(id);
+        expect(hex.length).toBe(32);
+        expect(/^[0-9a-f]{32}$/.test(hex)).toBe(true);
     });
-    it("parseId roundtrips with formatId (Base58)", () => {
+    it("parseId roundtrips with formatId", () => {
         const id = randomId();
-        const b58 = formatId(id);
-        const parsed = parseId(b58);
+        const hex = formatId(id);
+        const parsed = parseId(hex);
         expect(parsed).toBeDefined();
         expect(idsEqual(id, parsed)).toBe(true);
     });
-    it("parseId accepts hex for backwards compatibility", () => {
+    it("parseId accepts hyphens", () => {
         const withHyphens = "550e8400-e29b-41d4-a716-446655440000";
         const withoutHyphens = "550e8400e29b41d4a716446655440000";
         const id1 = parseId(withHyphens);
@@ -76,24 +97,24 @@ describe("ID utilities", () => {
 describe("Genesis IDs", () => {
     it("properties.NAME matches spec", () => {
         const id = properties.NAME;
-        expect(formatIdHex(id)).toBe("a126ca530c8e48d5b88882c734c38935");
+        expect(formatId(id)).toBe("a126ca530c8e48d5b88882c734c38935");
         expect(idsEqual(id, properties.name())).toBe(true);
     });
     it("properties.DESCRIPTION matches spec", () => {
         const id = properties.DESCRIPTION;
-        expect(formatIdHex(id)).toBe("9b1f76ff9711404c861e59dc3fa7d037");
+        expect(formatId(id)).toBe("9b1f76ff9711404c861e59dc3fa7d037");
     });
     it("properties.COVER matches spec", () => {
         const id = properties.COVER;
-        expect(formatIdHex(id)).toBe("34f535072e6b42c5a84443981a77cfa2");
+        expect(formatId(id)).toBe("34f535072e6b42c5a84443981a77cfa2");
     });
     it("types.IMAGE matches spec", () => {
         const id = types.IMAGE;
-        expect(formatIdHex(id)).toBe("f3f790c4c74e4d23a0a91e8ef84e30d9");
+        expect(formatId(id)).toBe("f3f790c4c74e4d23a0a91e8ef84e30d9");
     });
     it("relationTypes.TYPES matches spec", () => {
         const id = relationTypes.TYPES;
-        expect(formatIdHex(id)).toBe("8f151ba4de204e3c9cb499ddf96f48f1");
+        expect(formatId(id)).toBe("8f151ba4de204e3c9cb499ddf96f48f1");
         expect(idsEqual(id, relationTypes.types())).toBe(true);
     });
     it("languages.english is deterministic", () => {
@@ -1007,6 +1028,341 @@ it("throws when time or datetime is missing a timezone offset", () => {
     };
     expect(() => encodeEdit(edit)).toThrow("Invalid RFC 3339 time");
 });
+describe("Decimal normalization", () => {
+    it("normalizes i64 mantissa with trailing zeros", () => {
+        const editId = randomId();
+        const entityId = randomId();
+        const propId = randomId();
+        // mantissa 100, exponent -2 represents 1.00 — should normalize to mantissa 1, exponent 0
+        const edit = {
+            id: editId,
+            name: "Decimal Test",
+            authors: [],
+            createdAt: 0n,
+            ops: [
+                {
+                    type: "createEntity",
+                    id: entityId,
+                    values: [
+                        { property: propId, value: { type: "decimal", exponent: -2, mantissa: { type: "i64", value: 100n } } },
+                    ],
+                },
+            ],
+        };
+        const encoded = encodeEdit(edit);
+        const decoded = decodeEdit(encoded);
+        const op = decoded.ops[0];
+        expect(op.type).toBe("createEntity");
+        if (op.type === "createEntity") {
+            const val = op.values[0].value;
+            expect(val.type).toBe("decimal");
+            if (val.type === "decimal") {
+                // Should be normalized: 100 * 10^-2 = 1 * 10^0
+                expect(val.mantissa).toEqual({ type: "i64", value: 1n });
+                expect(val.exponent).toBe(0);
+            }
+        }
+    });
+    it("normalizes i64 mantissa 1230 with exponent -2", () => {
+        const editId = randomId();
+        const entityId = randomId();
+        const propId = randomId();
+        const edit = {
+            id: editId,
+            name: "Decimal Test",
+            authors: [],
+            createdAt: 0n,
+            ops: [
+                {
+                    type: "createEntity",
+                    id: entityId,
+                    values: [
+                        { property: propId, value: { type: "decimal", exponent: -2, mantissa: { type: "i64", value: 1230n } } },
+                    ],
+                },
+            ],
+        };
+        const encoded = encodeEdit(edit);
+        const decoded = decodeEdit(encoded);
+        const op = decoded.ops[0];
+        if (op.type === "createEntity") {
+            const val = op.values[0].value;
+            if (val.type === "decimal") {
+                // 1230 * 10^-2 = 123 * 10^-1
+                expect(val.mantissa).toEqual({ type: "i64", value: 123n });
+                expect(val.exponent).toBe(-1);
+            }
+        }
+    });
+    it("normalizes zero mantissa with non-zero exponent", () => {
+        const editId = randomId();
+        const entityId = randomId();
+        const propId = randomId();
+        const edit = {
+            id: editId,
+            name: "Decimal Test",
+            authors: [],
+            createdAt: 0n,
+            ops: [
+                {
+                    type: "createEntity",
+                    id: entityId,
+                    values: [
+                        { property: propId, value: { type: "decimal", exponent: 5, mantissa: { type: "i64", value: 0n } } },
+                    ],
+                },
+            ],
+        };
+        const encoded = encodeEdit(edit);
+        const decoded = decodeEdit(encoded);
+        const op = decoded.ops[0];
+        if (op.type === "createEntity") {
+            const val = op.values[0].value;
+            if (val.type === "decimal") {
+                expect(val.mantissa).toEqual({ type: "i64", value: 0n });
+                expect(val.exponent).toBe(0);
+            }
+        }
+    });
+    it("does not modify already-normalized decimals", () => {
+        const editId = randomId();
+        const entityId = randomId();
+        const propId = randomId();
+        const edit = {
+            id: editId,
+            name: "Decimal Test",
+            authors: [],
+            createdAt: 0n,
+            ops: [
+                {
+                    type: "createEntity",
+                    id: entityId,
+                    values: [
+                        { property: propId, value: { type: "decimal", exponent: -2, mantissa: { type: "i64", value: 12345n } } },
+                    ],
+                },
+            ],
+        };
+        const encoded = encodeEdit(edit);
+        const decoded = decodeEdit(encoded);
+        const op = decoded.ops[0];
+        if (op.type === "createEntity") {
+            const val = op.values[0].value;
+            if (val.type === "decimal") {
+                expect(val.mantissa).toEqual({ type: "i64", value: 12345n });
+                expect(val.exponent).toBe(-2);
+            }
+        }
+    });
+    it("normalizes negative mantissa with trailing zeros", () => {
+        const editId = randomId();
+        const entityId = randomId();
+        const propId = randomId();
+        const edit = {
+            id: editId,
+            name: "Decimal Test",
+            authors: [],
+            createdAt: 0n,
+            ops: [
+                {
+                    type: "createEntity",
+                    id: entityId,
+                    values: [
+                        { property: propId, value: { type: "decimal", exponent: 0, mantissa: { type: "i64", value: -500n } } },
+                    ],
+                },
+            ],
+        };
+        const encoded = encodeEdit(edit);
+        const decoded = decodeEdit(encoded);
+        const op = decoded.ops[0];
+        if (op.type === "createEntity") {
+            const val = op.values[0].value;
+            if (val.type === "decimal") {
+                // -500 * 10^0 = -5 * 10^2
+                expect(val.mantissa).toEqual({ type: "i64", value: -5n });
+                expect(val.exponent).toBe(2);
+            }
+        }
+    });
+    it("normalizes big mantissa with trailing zeros", () => {
+        const editId = randomId();
+        const entityId = randomId();
+        const propId = randomId();
+        // Big-endian two's complement for 500: 0x01F4
+        const bigBytes = new Uint8Array([0x01, 0xF4]);
+        const edit = {
+            id: editId,
+            name: "Decimal Test",
+            authors: [],
+            createdAt: 0n,
+            ops: [
+                {
+                    type: "createEntity",
+                    id: entityId,
+                    values: [
+                        { property: propId, value: { type: "decimal", exponent: 0, mantissa: { type: "big", bytes: bigBytes } } },
+                    ],
+                },
+            ],
+        };
+        const encoded = encodeEdit(edit);
+        const decoded = decodeEdit(encoded);
+        const op = decoded.ops[0];
+        if (op.type === "createEntity") {
+            const val = op.values[0].value;
+            if (val.type === "decimal") {
+                // 500 * 10^0 = 5 * 10^2, and 5 fits in i64
+                expect(val.mantissa).toEqual({ type: "i64", value: 5n });
+                expect(val.exponent).toBe(2);
+            }
+        }
+    });
+    it("normalizes raw decoded decimals so TypeScript matches Rust", () => {
+        const writer = new Writer();
+        writer.writeSignedVarint(-2n);
+        writer.writeByte(0x00);
+        writer.writeSignedVarint(100n);
+        const decoded = decodeValuePayload(new Reader(writer.finish()), DataType.Decimal);
+        expect(decoded).toEqual({
+            type: "decimal",
+            exponent: 0,
+            mantissa: { type: "i64", value: 1n },
+        });
+    });
+    it("normalizes raw decoded large big mantissas without truncation", () => {
+        const large = new Uint8Array([0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+        const writer = new Writer();
+        writer.writeSignedVarint(0n);
+        writer.writeByte(0x01);
+        writer.writeLengthPrefixedBytes(large);
+        const decoded = decodeValuePayload(new Reader(writer.finish()), DataType.Decimal);
+        expect(decoded).toEqual({
+            type: "decimal",
+            exponent: 1,
+            mantissa: {
+                type: "big",
+                bytes: new Uint8Array([0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
+            },
+        });
+    });
+    it("keeps negative big power-of-two mantissas minimally encoded", () => {
+        const writer = new Writer();
+        encodeValuePayload(writer, {
+            type: "decimal",
+            exponent: 0,
+            mantissa: {
+                type: "big",
+                bytes: new Uint8Array([0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
+            },
+        });
+        const reader = new Reader(writer.finish());
+        expect(reader.readSignedVarint()).toBe(0n);
+        expect(reader.readByte()).toBe(0x01);
+        const encodedBytes = reader.readLengthPrefixedBytes();
+        expect(encodedBytes).toEqual(new Uint8Array([0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]));
+    });
+    it("re-encodes non-minimal big mantissas to canonical bytes", () => {
+        const writer = new Writer();
+        encodeValuePayload(writer, {
+            type: "decimal",
+            exponent: 0,
+            mantissa: {
+                type: "big",
+                bytes: new Uint8Array([0x00, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01]),
+            },
+        });
+        const reader = new Reader(writer.finish());
+        expect(reader.readSignedVarint()).toBe(0n);
+        expect(reader.readByte()).toBe(0x01);
+        expect(reader.readLengthPrefixedBytes()).toEqual(new Uint8Array([0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01]));
+    });
+    it("rejects non-minimal decimal mantissa bytes on decode", () => {
+        const writer = new Writer();
+        writer.writeSignedVarint(0n);
+        writer.writeByte(0x01);
+        writer.writeLengthPrefixedBytes(new Uint8Array([0x00, 0x7F]));
+        expect(() => decodeValuePayload(new Reader(writer.finish()), DataType.Decimal))
+            .toThrow("decimal mantissa bytes are not minimal");
+    });
+    it("rejects empty big mantissa bytes on decode", () => {
+        const writer = new Writer();
+        writer.writeSignedVarint(0n);
+        writer.writeByte(0x01);
+        writer.writeLengthPrefixedBytes(new Uint8Array([]));
+        expect(() => decodeValuePayload(new Reader(writer.finish()), DataType.Decimal))
+            .toThrow("decimal mantissa bytes are not minimal");
+    });
+    it("rejects empty big mantissa bytes on encode", () => {
+        const writer = new Writer();
+        expect(() => encodeValuePayload(writer, {
+            type: "decimal",
+            exponent: 0,
+            mantissa: { type: "big", bytes: new Uint8Array([]) },
+        })).toThrow("DECIMAL mantissa bytes must not be empty");
+    });
+    it("rejects decimal big mantissas over the maximum on encode", () => {
+        const writer = new Writer();
+        const oversized = new Uint8Array(64 * 1024 * 1024 + 1);
+        oversized[0] = 1;
+        expect(() => encodeValuePayload(writer, {
+            type: "decimal",
+            exponent: 0,
+            mantissa: { type: "big", bytes: oversized },
+        })).toThrow("decimal mantissa length 67108865 exceeds maximum 67108864");
+    });
+    it("rejects excessive decimal normalization work on decode", () => {
+        const writer = new Writer();
+        const bytes = positiveBigIntToMinimalTwosComplement(10n ** 4097n);
+        writer.writeSignedVarint(0n);
+        writer.writeByte(0x01);
+        writer.writeLengthPrefixedBytes(bytes);
+        expect(() => decodeValuePayload(new Reader(writer.finish()), DataType.Decimal))
+            .toThrow("DECIMAL normalization exceeds maximum steps");
+    });
+    it("rejects excessive decimal normalization work on encode", () => {
+        const writer = new Writer();
+        expect(() => encodeValuePayload(writer, {
+            type: "decimal",
+            exponent: 0,
+            mantissa: { type: "big", bytes: positiveBigIntToMinimalTwosComplement(10n ** 4097n) },
+        })).toThrow("DECIMAL normalization exceeds maximum steps");
+    });
+    it("rejects exponents outside int32 range on decode", () => {
+        const writer = new Writer();
+        writer.writeSignedVarint(2147483648n);
+        writer.writeByte(0x00);
+        writer.writeSignedVarint(1n);
+        expect(() => decodeValuePayload(new Reader(writer.finish()), DataType.Decimal))
+            .toThrow("DECIMAL exponent outside int32 range");
+    });
+    it("rejects exponent overflow during decode-time normalization", () => {
+        const writer = new Writer();
+        writer.writeSignedVarint(2147483647n);
+        writer.writeByte(0x00);
+        writer.writeSignedVarint(10n);
+        expect(() => decodeValuePayload(new Reader(writer.finish()), DataType.Decimal))
+            .toThrow("DECIMAL exponent outside int32 range");
+    });
+    it("rejects exponent overflow during encode-time normalization", () => {
+        const writer = new Writer();
+        expect(() => encodeValuePayload(writer, {
+            type: "decimal",
+            exponent: 2147483647,
+            mantissa: { type: "i64", value: 10n },
+        })).toThrow("DECIMAL exponent outside int32 range");
+    });
+    it("rejects decimal big mantissa lengths over the maximum", () => {
+        const writer = new Writer();
+        writer.writeSignedVarint(0n);
+        writer.writeByte(0x01);
+        writer.writeVarintNumber(64 * 1024 * 1024 + 1);
+        expect(() => decodeValuePayload(new Reader(writer.finish()), DataType.Decimal))
+            .toThrow("decimal mantissa length 67108865 exceeds maximum 67108864");
+    });
+});
 describe("Compression", () => {
     it("isCompressed detects GRC2Z magic", () => {
         const compressed = new Uint8Array([0x47, 0x52, 0x43, 0x32, 0x5a, 0x00]); // "GRC2Z" + data