@willieee802/zigbee-herdsman 0.48.3 → 0.49.0

package/test/adapter/zboss/fixZdoResponse.test.ts

@@ -0,0 +1,179 @@
+import {describe, expect, it} from "vitest";
+import {CommandId} from "../../../src/adapter/zboss/enums";
+import {FrameType, readZBOSSFrame, type ZBOSSFrame} from "../../../src/adapter/zboss/frame";
+import * as Zdo from "../../../src/zspec/zdo";
+import type * as ZdoTypes from "../../../src/zspec/zdo/definition/tstypes";
+
+describe("ZBOSS fix non-standard ZDO response payloads", () => {
+    it("No fix needed FrameType.RESPONSE", () => {
+        expect(readZBOSSFrame(Buffer.from("0001010211000088776655443322113412", "hex"))).toStrictEqual({
+            version: 0,
+            type: FrameType.RESPONSE,
+            commandId: CommandId.ZDO_NWK_ADDR_REQ,
+            tsn: 17,
+            payload: {
+                category: 0,
+                zdoClusterId: Zdo.ClusterId.NETWORK_ADDRESS_RESPONSE,
+                zdo: [
+                    Zdo.Status.SUCCESS,
+                    {
+                        nwkAddress: 0x1234,
+                        eui64: "0x1122334455667788",
+                        startIndex: 0,
+                        assocDevList: [],
+                    } as ZdoTypes.NetworkAddressResponse,
+                ],
+            },
+        } as ZBOSSFrame);
+    });
+
+    it("No fix needed FrameType.INDICATION", () => {
+        expect(readZBOSSFrame(Buffer.from("00020c020cda603602602bd5b3708e", "hex"))).toStrictEqual({
+            version: 0,
+            type: FrameType.INDICATION,
+            commandId: CommandId.ZDO_DEV_ANNCE_IND,
+            tsn: 0,
+            payload: {
+                category: undefined,
+                zdoClusterId: Zdo.ClusterId.END_DEVICE_ANNOUNCE,
+                zdo: [
+                    Zdo.Status.SUCCESS,
+                    {
+                        nwkAddress: 0xda0c,
+                        eui64: "0x70b3d52b60023660",
+                        capabilities: Zdo.Utils.getMacCapFlags(0x8e),
+                    } as ZdoTypes.EndDeviceAnnounce,
+                ],
+            },
+        } as ZBOSSFrame);
+    });
+
+    it("NODE_DESCRIPTOR_RESPONSE", () => {
+        expect(readZBOSSFrame(Buffer.from("000104021100000000000000000000432c0000003412", "hex"))).toStrictEqual({
+            version: 0,
+            type: FrameType.RESPONSE,
+            commandId: CommandId.ZDO_NODE_DESC_REQ,
+            tsn: 17,
+            payload: {
+                category: 0,
+                zdoClusterId: Zdo.ClusterId.NODE_DESCRIPTOR_RESPONSE,
+                zdo: [
+                    Zdo.Status.SUCCESS,
+                    {
+                        nwkAddress: 0x1234,
+                        logicalType: 0,
+                        fragmentationSupported: undefined,
+                        apsFlags: 0,
+                        frequencyBand: 0,
+                        capabilities: {
+                            alternatePANCoordinator: 0,
+                            deviceType: 0,
+                            powerSource: 0,
+                            rxOnWhenIdle: 0,
+                            reserved1: 0,
+                            reserved2: 0,
+                            securityCapability: 0,
+                            allocateAddress: 0,
+                        },
+                        manufacturerCode: 0,
+                        maxBufSize: 0,
+                        maxIncTxSize: 0,
+                        serverMask: Zdo.Utils.getServerMask(0x2c43),
+                        maxOutTxSize: 0,
+                        deprecated1: 0,
+                        tlvs: [],
+                    } as ZdoTypes.NodeDescriptorResponse,
+                ],
+            },
+        } as ZBOSSFrame);
+    });
+
+    it("POWER_DESCRIPTOR_RESPONSE", () => {
+        expect(readZBOSSFrame(Buffer.from("0001030211000001023412", "hex"))).toStrictEqual({
+            version: 0,
+            type: FrameType.RESPONSE,
+            commandId: CommandId.ZDO_POWER_DESC_REQ,
+            tsn: 17,
+            payload: {
+                category: 0,
+                zdoClusterId: Zdo.ClusterId.POWER_DESCRIPTOR_RESPONSE,
+                zdo: [
+                    Zdo.Status.SUCCESS,
+                    {
+                        nwkAddress: 0x1234,
+                        currentPowerMode: 1,
+                        availPowerSources: 0,
+                        currentPowerSource: 2,
+                        currentPowerSourceLevel: 0,
+                    } as ZdoTypes.PowerDescriptorResponse,
+                ],
+            },
+        } as ZBOSSFrame);
+    });
+
+    it("MATCH_DESCRIPTORS_RESPONSE", () => {
+        expect(readZBOSSFrame(Buffer.from("0001070211000002f2013412", "hex"))).toStrictEqual({
+            version: 0,
+            type: FrameType.RESPONSE,
+            commandId: CommandId.ZDO_MATCH_DESC_REQ,
+            tsn: 17,
+            payload: {
+                category: 0,
+                zdoClusterId: Zdo.ClusterId.MATCH_DESCRIPTORS_RESPONSE,
+                zdo: [
+                    Zdo.Status.SUCCESS,
+                    {
+                        nwkAddress: 0x1234,
+                        endpointList: [242, 1],
+                    } as ZdoTypes.MatchDescriptorsResponse,
+                ],
+            },
+        } as ZBOSSFrame);
+    });
+
+    it("ACTIVE_ENDPOINTS_RESPONSE", () => {
+        expect(readZBOSSFrame(Buffer.from("0001060211000002f2013412", "hex"))).toStrictEqual({
+            version: 0,
+            type: FrameType.RESPONSE,
+            commandId: CommandId.ZDO_ACTIVE_EP_REQ,
+            tsn: 17,
+            payload: {
+                category: 0,
+                zdoClusterId: Zdo.ClusterId.ACTIVE_ENDPOINTS_RESPONSE,
+                zdo: [
+                    Zdo.Status.SUCCESS,
+                    {
+                        nwkAddress: 0x1234,
+                        endpointList: [242, 1],
+                    } as ZdoTypes.ActiveEndpointsResponse,
+                ],
+            },
+        } as ZBOSSFrame);
+    });
+
+    it("SIMPLE_DESCRIPTOR_RESPONSE", () => {
+        expect(readZBOSSFrame(Buffer.from("0001050211000001040100000301022c2ffefebcbc3412", "hex"))).toStrictEqual({
+            version: 0,
+            type: FrameType.RESPONSE,
+            commandId: CommandId.ZDO_SIMPLE_DESC_REQ,
+            tsn: 17,
+            payload: {
+                category: 0,
+                zdoClusterId: Zdo.ClusterId.SIMPLE_DESCRIPTOR_RESPONSE,
+                zdo: [
+                    Zdo.Status.SUCCESS,
+                    {
+                        nwkAddress: 0x1234,
+                        length: 14,
+                        endpoint: 1,
+                        profileId: 0x0104,
+                        deviceId: 0x0000,
+                        deviceVersion: 3,
+                        inClusterList: [0x2f2c],
+                        outClusterList: [0xfefe, 0xbcbc],
+                    } as ZdoTypes.SimpleDescriptorResponse,
+                ],
+            },
+        } as ZBOSSFrame);
+    });
+});

package/test/adapter/zigate/patchZdoBuffaloBE.test.ts

@@ -0,0 +1,81 @@
+import {beforeAll, describe, expect, it, vi} from "vitest";
+import * as Zdo from "../../../src/zspec/zdo";
+
+describe("ZiGate Patch BuffaloZdo to use BE variants when writing", () => {
+    let BuffaloZdo: typeof Zdo.Buffalo;
+
+    beforeAll(async () => {
+        vi.resetModules();
+
+        const buf = await import("../../../src/zspec/zdo/buffaloZdo.js");
+        BuffaloZdo = buf.BuffaloZdo;
+        const {ZiGateAdapter} = await import("../../../src/adapter/zigate/adapter/zigateAdapter.js");
+        // @ts-expect-error bogus, just need to trigger constructor
+        new ZiGateAdapter({}, {}, "", {});
+    });
+
+    it("writeUInt16", () => {
+        expect(BuffaloZdo.buildRequest(false, Zdo.ClusterId.IEEE_ADDRESS_REQUEST, 0x1234, false, 0)).toStrictEqual(
+            Buffer.from([0x12, 0x34, 0x00, 0x00]),
+        );
+
+        // ensure regular parsing OK
+        expect(Zdo.Buffalo.buildRequest(false, Zdo.ClusterId.IEEE_ADDRESS_REQUEST, 0x1234, false, 0)).toStrictEqual(
+            Buffer.from([0x34, 0x12, 0x00, 0x00]),
+        );
+    });
+
+    it("writeUInt32", () => {
+        expect(BuffaloZdo.buildRequest(false, Zdo.ClusterId.NWK_UPDATE_REQUEST, [15], 0xfe, undefined, undefined, undefined)).toStrictEqual(
+            Buffer.from([0x00, 0x00, 0x80, 0x00, 0xfe]),
+        );
+
+        // ensure regular parsing OK
+        expect(Zdo.Buffalo.buildRequest(false, Zdo.ClusterId.NWK_UPDATE_REQUEST, [15], 0xfe, undefined, undefined, undefined)).toStrictEqual(
+            Buffer.from([0x00, 0x80, 0x00, 0x00, 0xfe]),
+        );
+    });
+
+    it("readUInt16 + readUInt32 - LE", () => {
+        expect(
+            BuffaloZdo.readResponse(
+                true,
+                Zdo.ClusterId.NWK_UPDATE_RESPONSE,
+                Buffer.from([0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x12, 0x34, 0x00, 0x01, 0x01, 0x12]),
+            ),
+        ).toStrictEqual(
+            Zdo.Buffalo.readResponse(
+                true,
+                Zdo.ClusterId.NWK_UPDATE_RESPONSE,
+                Buffer.from([0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x12, 0x34, 0x00, 0x01, 0x01, 0x12]),
+            ),
+        );
+    });
+
+    it("writeIeeeAddr", () => {
+        expect(BuffaloZdo.buildRequest(false, Zdo.ClusterId.NETWORK_ADDRESS_REQUEST, "0x1122334455667788", false, 0)).toStrictEqual(
+            Buffer.from([0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x00, 0x00]),
+        );
+
+        // ensure regular parsing OK
+        expect(Zdo.Buffalo.buildRequest(false, Zdo.ClusterId.NETWORK_ADDRESS_REQUEST, "0x1122334455667788", false, 0)).toStrictEqual(
+            Buffer.from([0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x00, 0x00]),
+        );
+    });
+
+    it("readIeeeAddr - LE", () => {
+        expect(
+            BuffaloZdo.readResponse(
+                true,
+                Zdo.ClusterId.IEEE_ADDRESS_RESPONSE,
+                Buffer.from([0x01, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x12, 0x34]),
+            ),
+        ).toStrictEqual(
+            Zdo.Buffalo.readResponse(
+                true,
+                Zdo.ClusterId.IEEE_ADDRESS_RESPONSE,
+                Buffer.from([0x01, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x12, 0x34]),
+            ),
+        );
+    });
+});

package/test/adapter/zigate/zdo.test.ts

@@ -0,0 +1,187 @@
+import type {MockInstance} from "vitest";
+import {beforeEach, describe, expect, it, vi} from "vitest";
+import {ZiGateAdapter} from "../../../src/adapter/zigate/adapter/zigateAdapter";
+import {BLANK_EUI64} from "../../../src/zspec";
+import * as Zdo from "../../../src/zspec/zdo";
+
+describe("ZiGate ZDO payloads", () => {
+    let adapter: ZiGateAdapter;
+    let requestZdoSpy: MockInstance;
+
+    beforeEach(() => {
+        adapter = new ZiGateAdapter({panID: 0, channelList: [11]}, {}, "tmp.db.backup", {disableLED: false});
+        requestZdoSpy = vi
+            .spyOn(
+                // @ts-expect-error private
+                adapter.driver,
+                "requestZdo",
+            )
+            .mockResolvedValue(true);
+    });
+
+    it("ZiGateCommandCode.ManagementLQI", async () => {
+        // const ziPayload = ZiGateObject.createRequest(ZiGateCommandCode.ManagementLQI, {
+        //     targetAddress: 0x1122,
+        //     startIndex: 0,
+        // });
+        // console.log(ziPayload.toZiGateFrame().msgPayloadBytes.toString('hex'));
+        // 112200
+        const clusterId = Zdo.ClusterId.LQI_TABLE_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(false, clusterId, 0);
+        await adapter.sendZdo("0x1122334455667788", 0x1122, clusterId, zdoPayload, true);
+        expect(requestZdoSpy).toHaveBeenCalledWith(clusterId, Buffer.from("112200", "hex"));
+    });
+
+    it("ZiGateCommandCode.LeaveRequest", async () => {
+        // const ziPayload = ZiGateObject.createRequest(ZiGateCommandCode.LeaveRequest, {
+        //     extendedAddress: '0x1122334455667788',
+        //     rejoin: 0,
+        //     removeChildren: 0,
+        // });
+        // console.log(ziPayload.toZiGateFrame().msgPayloadBytes.toString('hex'));
+        // 11223344556677880000
+        const clusterId = Zdo.ClusterId.LEAVE_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(false, clusterId, "0x1122334455667788", Zdo.LeaveRequestFlags.WITHOUT_REJOIN);
+        await adapter.sendZdo("0x1122334455667788", 0x1122, clusterId, zdoPayload, true);
+        expect(requestZdoSpy).toHaveBeenCalledWith(clusterId, Buffer.from("11223344556677880000", "hex"));
+    });
+
+    it("ZiGateCommandCode.PermitJoin", async () => {
+        // const ziPayload = ZiGateObject.createRequest(ZiGateCommandCode.PermitJoin, {
+        //     targetShortAddress: 0x1122,
+        //     interval: 254,
+        //     TCsignificance: 1,
+        // });
+        // console.log(ziPayload.toZiGateFrame().msgPayloadBytes.toString('hex'));
+        // 1122fe01
+        const clusterId = Zdo.ClusterId.PERMIT_JOINING_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(false, clusterId, 254, 1, []);
+        await adapter.sendZdo("0x1122334455667788", 0x1122, clusterId, zdoPayload, true);
+        expect(requestZdoSpy).toHaveBeenCalledWith(clusterId, Buffer.from("1122fe01", "hex"));
+    });
+
+    it("ZiGateCommandCode.NodeDescriptor", async () => {
+        // const ziPayload = ZiGateObject.createRequest(ZiGateCommandCode.NodeDescriptor, {
+        //     targetShortAddress: 0x1122,
+        // });
+        // console.log(ziPayload.toZiGateFrame().msgPayloadBytes.toString('hex'));
+        // 1122
+        const clusterId = Zdo.ClusterId.NODE_DESCRIPTOR_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(false, clusterId, 0x1122);
+        await adapter.sendZdo("0x1122334455667788", 0x1122, clusterId, zdoPayload, true);
+        expect(requestZdoSpy).toHaveBeenCalledWith(clusterId, Buffer.from("1122", "hex"));
+    });
+
+    it("ZiGateCommandCode.ActiveEndpoint", async () => {
+        // const ziPayload = ZiGateObject.createRequest(ZiGateCommandCode.ActiveEndpoint, {
+        //     targetShortAddress: 0x1122,
+        // });
+        // console.log(ziPayload.toZiGateFrame().msgPayloadBytes.toString('hex'));
+        // 1122
+        const clusterId = Zdo.ClusterId.ACTIVE_ENDPOINTS_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(false, clusterId, 0x1122);
+        await adapter.sendZdo("0x1122334455667788", 0x1122, clusterId, zdoPayload, true);
+        expect(requestZdoSpy).toHaveBeenCalledWith(clusterId, Buffer.from("1122", "hex"));
+    });
+
+    it("ZiGateCommandCode.SimpleDescriptor", async () => {
+        // const ziPayload = ZiGateObject.createRequest(ZiGateCommandCode.SimpleDescriptor, {
+        //     targetShortAddress: 0x1122,
+        //     endpoint: 3,
+        // });
+        // console.log(ziPayload.toZiGateFrame().msgPayloadBytes.toString('hex'));
+        // 112203
+        const clusterId = Zdo.ClusterId.SIMPLE_DESCRIPTOR_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(false, clusterId, 0x1122, 3);
+        await adapter.sendZdo("0x1122334455667788", 0x1122, clusterId, zdoPayload, true);
+        expect(requestZdoSpy).toHaveBeenCalledWith(clusterId, Buffer.from("112203", "hex"));
+    });
+
+    it("ZiGateCommandCode.Bind - UNICAST", async () => {
+        // const ziPayload = ZiGateObject.createRequest(ZiGateCommandCode.Bind, {
+        //     targetExtendedAddress: '0x1122334455667788',
+        //     targetEndpoint: 5,
+        //     clusterID: 0x4567,
+        //     destinationAddressMode: Zdo.UNICAST_BINDING,
+        //     destinationAddress: '0x9911882277336644',
+        //     destinationEndpoint: 3,
+        // });
+        // console.log(ziPayload.toZiGateFrame().msgPayloadBytes.toString('hex'));
+        // 112233445566778805456703991188227733664403
+        const clusterId = Zdo.ClusterId.BIND_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(
+            false,
+            clusterId,
+            "0x1122334455667788",
+            5,
+            0x4567,
+            Zdo.UNICAST_BINDING,
+            "0x9911882277336644",
+            0,
+            3,
+        );
+        await adapter.sendZdo("0x1122334455667788", 0x1122, clusterId, zdoPayload, true);
+        expect(requestZdoSpy).toHaveBeenCalledWith(clusterId, Buffer.from("112233445566778805456703991188227733664403", "hex"));
+    });
+
+    it("ZiGateCommandCode.Bind - MULTICAST", async () => {
+        // const ziPayload = ZiGateObject.createRequest(ZiGateCommandCode.Bind, {
+        //     targetExtendedAddress: '0x1122334455667788',
+        //     targetEndpoint: 5,
+        //     clusterID: 0x4567,
+        //     destinationAddressMode: Zdo.MULTICAST_BINDING,
+        //     destinationAddress: 0x3456,
+        //     destinationEndpoint: 0,
+        // });
+        // console.log(ziPayload.toZiGateFrame().msgPayloadBytes.toString('hex'));
+        // 112233445566778805456701345600
+        const clusterId = Zdo.ClusterId.BIND_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(false, clusterId, "0x1122334455667788", 5, 0x4567, Zdo.MULTICAST_BINDING, BLANK_EUI64, 0x3456, 0);
+        await adapter.sendZdo("0x1122334455667788", 0x1122, clusterId, zdoPayload, true);
+        expect(requestZdoSpy).toHaveBeenCalledWith(clusterId, Buffer.from("112233445566778805456701345600", "hex"));
+    });
+
+    it("ZiGateCommandCode.UnBind - UNICAST", async () => {
+        // const ziPayload = ZiGateObject.createRequest(ZiGateCommandCode.UnBind, {
+        //     targetExtendedAddress: '0x1122334455667788',
+        //     targetEndpoint: 5,
+        //     clusterID: 0x4567,
+        //     destinationAddressMode: Zdo.UNICAST_BINDING,
+        //     destinationAddress: '0x9911882277336644',
+        //     destinationEndpoint: 3,
+        // });
+        // console.log(ziPayload.toZiGateFrame().msgPayloadBytes.toString('hex'));
+        // 112233445566778805456703991188227733664403
+        const clusterId = Zdo.ClusterId.UNBIND_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(
+            false,
+            clusterId,
+            "0x1122334455667788",
+            5,
+            0x4567,
+            Zdo.UNICAST_BINDING,
+            "0x9911882277336644",
+            0,
+            3,
+        );
+        await adapter.sendZdo("0x1122334455667788", 0x1122, clusterId, zdoPayload, true);
+        expect(requestZdoSpy).toHaveBeenCalledWith(clusterId, Buffer.from("112233445566778805456703991188227733664403", "hex"));
+    });
+
+    it("ZiGateCommandCode.UnBind - MULTICAST", async () => {
+        // const ziPayload = ZiGateObject.createRequest(ZiGateCommandCode.UnBind, {
+        //     targetExtendedAddress: '0x1122334455667788',
+        //     targetEndpoint: 5,
+        //     clusterID: 0x4567,
+        //     destinationAddressMode: Zdo.MULTICAST_BINDING,
+        //     destinationAddress: 0x3456,
+        //     destinationEndpoint: 0,
+        // });
+        // console.log(ziPayload.toZiGateFrame().msgPayloadBytes.toString('hex'));
+        // 112233445566778805456701345600
+        const clusterId = Zdo.ClusterId.UNBIND_REQUEST;
+        const zdoPayload = Zdo.Buffalo.buildRequest(false, clusterId, "0x1122334455667788", 5, 0x4567, Zdo.MULTICAST_BINDING, BLANK_EUI64, 0x3456, 0);
+        await adapter.sendZdo("0x1122334455667788", 0x1122, clusterId, zdoPayload, true);
+        expect(requestZdoSpy).toHaveBeenCalledWith(clusterId, Buffer.from("112233445566778805456701345600", "hex"));
+    });
+});

package/test/adapter/zoh/utils.test.ts

@@ -0,0 +1,36 @@
+import {describe, expect, it} from "vitest";
+import {bigUInt64ToBufferBE, bigUInt64ToBufferLE, bigUInt64ToHexBE} from "../../../src/adapter/zoh/adapter/utils";
+
+describe("ZoH Utils", () => {
+    it("handles bigint conversions", () => {
+        const v10x = "0x90395efffec7fd21";
+        const v1Buf = Buffer.from([0x21, 0xfd, 0xc7, 0xfe, 0xff, 0x5e, 0x39, 0x90]);
+        const v1BigInt = 10392442068718320929n;
+
+        const v20x = "0x9986ffbb4523acef";
+        const v2Buf = Buffer.from([0xef, 0xac, 0x23, 0x45, 0xbb, 0xff, 0x86, 0x99]);
+        const v2BigInt = 11062810714466135279n;
+
+        const v30x = "0x0322334455667788";
+        const v3Buf = Buffer.from([0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x03]);
+        const v3BigInt = 225799299905517448n;
+
+        expect(bigUInt64ToHexBE(v1BigInt)).toStrictEqual(v10x.slice(2));
+        expect(bigUInt64ToBufferLE(v1BigInt)).toStrictEqual(v1Buf);
+        expect(bigUInt64ToBufferBE(v1BigInt)).toStrictEqual(Buffer.from(v1Buf).reverse());
+        expect(BigInt(v10x)).toStrictEqual(v1BigInt);
+        expect(v1Buf.readBigUInt64LE(0)).toStrictEqual(v1BigInt);
+
+        expect(bigUInt64ToHexBE(v2BigInt)).toStrictEqual(v20x.slice(2));
+        expect(bigUInt64ToBufferLE(v2BigInt)).toStrictEqual(v2Buf);
+        expect(bigUInt64ToBufferBE(v2BigInt)).toStrictEqual(Buffer.from(v2Buf).reverse());
+        expect(BigInt(v20x)).toStrictEqual(v2BigInt);
+        expect(v2Buf.readBigUInt64LE(0)).toStrictEqual(v2BigInt);
+
+        expect(bigUInt64ToHexBE(v3BigInt)).toStrictEqual(v30x.slice(2));
+        expect(bigUInt64ToBufferLE(v3BigInt)).toStrictEqual(v3Buf);
+        expect(bigUInt64ToBufferBE(v3BigInt)).toStrictEqual(Buffer.from(v3Buf).reverse());
+        expect(BigInt(v30x)).toStrictEqual(v3BigInt);
+        expect(v3Buf.readBigUInt64LE(0)).toStrictEqual(v3BigInt);
+    });
+});