@gsknnft/bigint-buffer 1.4.1 → 1.4.2

package/src/index.spec.ts

@@ -0,0 +1,318 @@
+import { beforeAll, describe, expect, it } from "vitest";
+
+let lib: Awaited<typeof import("./index.js")>;
+let toBigIntBE: Awaited<typeof import("./index.js")>["toBigIntBE"];
+let toBigIntLE: Awaited<typeof import("./index.js")>["toBigIntLE"];
+let toBufferBE: Awaited<typeof import("./index.js")>["toBufferBE"];
+let toBufferLE: Awaited<typeof import("./index.js")>["toBufferLE"];
+// Removed unused variable assignments to fix lint errors
+
+beforeAll(async () => {
+  lib = await import("./index.js");
+  toBigIntBE = lib.toBigIntBE;
+  toBigIntLE = lib.toBigIntLE;
+  toBufferBE = lib.toBufferBE;
+  toBufferLE = lib.toBufferLE;
+  // Removed assignments to undeclared variables
+});
+
+const assertEquals = (n0: bigint, n1: bigint) => {
+  expect(n0.toString(16)).toBe(n1.toString(16));
+};
+
+describe("Try buffer conversion (little endian)", () => {
+  it("0 should equal 0n", () => {
+    assertEquals(toBigIntLE(Buffer.from([0])), BigInt("0"));
+  });
+
+  it("1 should equal 1n", async () => {
+    assertEquals(toBigIntLE(Buffer.from([1])), BigInt("1"));
+  });
+
+  it("0xdead should equal 0xdeadn", async () => {
+    assertEquals(toBigIntLE(Buffer.from([0xad, 0xde])), BigInt("0xdead"));
+  });
+
+  it("0xdeadbeef should equal 0xdeadbeefn", async () => {
+    assertEquals(
+      toBigIntLE(Buffer.from([0xef, 0xbe, 0xad, 0xde])),
+      BigInt("0xdeadbeef")
+    );
+  });
+
+  it("0xbadc0ffee0 should equal 0xbadc0ffee0n", async () => {
+    assertEquals(
+      toBigIntLE(Buffer.from([0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
+      BigInt("0xbadc0ffee0")
+    );
+  });
+
+  it("0xbadc0ffee0dd should equal 0xbadc0ffee0ddn", async () => {
+    assertEquals(
+      toBigIntLE(Buffer.from([0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
+      BigInt("0xbadc0ffee0dd")
+    );
+  });
+
+  it("0xbadc0ffee0ddf0 should equal 0xbadc0ffee0ddf0n", async () => {
+    assertEquals(
+      toBigIntLE(Buffer.from([0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
+      BigInt("0xbadc0ffee0ddf0")
+    );
+  });
+
+  it("0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn", async () => {
+    assertEquals(
+      toBigIntLE(Buffer.from([0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
+      BigInt("0xbadc0ffee0ddf00d")
+    );
+  });
+
+  it("0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn", async () => {
+    assertEquals(
+      toBigIntLE(
+        Buffer.from([
+          0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc,
+          0xba,
+        ])
+      ),
+      BigInt("0xbadc0ffee0ddf00ddeadbeef")
+    );
+  });
+
+  it("0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefn", async () => {
+    assertEquals(
+      toBigIntLE(
+        Buffer.from([
+          0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc,
+          0xba, 0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f,
+          0xdc, 0xba,
+        ])
+      ),
+      BigInt("0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef")
+    );
+  });
+
+  it("0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbeef should equal 0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbeefn", async () => {
+    assertEquals(
+      toBigIntLE(
+        Buffer.from([
+          0xef, 0xbe, 0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0, 0xfe,
+          0x0f, 0xdc, 0xba, 0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0,
+          0xfe, 0x0f, 0xdc, 0xba,
+        ])
+      ),
+      BigInt("0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbeef")
+    );
+  });
+});
+
+describe("Try buffer conversion (big endian)", () => {
+  it("0 should equal 0n", () => {
+    assertEquals(toBigIntBE(Buffer.from([0])), BigInt("0"));
+  });
+
+  it("1 should equal 1n", async () => {
+    assertEquals(toBigIntBE(Buffer.from([1])), BigInt("1"));
+  });
+
+  it("0xdead should equal 0xdeadn", async () => {
+    assertEquals(toBigIntBE(Buffer.from([0xde, 0xad])), BigInt("0xdead"));
+  });
+
+  it("0xdeadbeef should equal 0xdeadbeefn", async () => {
+    assertEquals(
+      toBigIntBE(Buffer.from([0xde, 0xad, 0xbe, 0xef])),
+      BigInt("0xdeadbeef")
+    );
+  });
+
+  it("0xbadc0ffee0 should equal 0xbadc0ffee0n", async () => {
+    assertEquals(
+      toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0])),
+      BigInt("0xbadc0ffee0")
+    );
+  });
+
+  it("0xbadc0ffee0dd should equal 0xbadc0ffee0ddn", async () => {
+    assertEquals(
+      toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd])),
+      BigInt("0xbadc0ffee0dd")
+    );
+  });
+
+  it("0xbadc0ffee0ddf0 should equal 0xbadc0ffee0ddf0n", async () => {
+    assertEquals(
+      toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0])),
+      BigInt("0xbadc0ffee0ddf0")
+    );
+  });
+
+  it("0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn", async () => {
+    assertEquals(
+      toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d])),
+      BigInt("0xbadc0ffee0ddf00d")
+    );
+  });
+
+  it("0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn", async () => {
+    assertEquals(
+      toBigIntBE(Buffer.from("badc0ffee0ddf00ddeadbeef", "hex")),
+      BigInt("0xbadc0ffee0ddf00ddeadbeef")
+    );
+  });
+
+  it("long value should equal long val", async () => {
+    assertEquals(
+      toBigIntBE(
+        Buffer.from(
+          "badc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef",
+          "hex"
+        )
+      ),
+      BigInt(
+        "0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef"
+      )
+    );
+  });
+
+  it("other long value should equal long val", async () => {
+    assertEquals(
+      toBigIntBE(
+        Buffer.from(
+          "d7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544",
+          "hex"
+        )
+      ),
+      BigInt(
+        "0xd7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544"
+      )
+    );
+  });
+});
+
+describe("Try bigint conversion (little endian)", () => {
+  it("0 should equal 0n", () => {
+    expect(toBufferLE(BigInt("0"), 8)).toEqual(
+      Buffer.from([0, 0, 0, 0, 0, 0, 0, 0])
+    );
+  });
+
+  it("1 should equal 1n", async () => {
+    expect(toBufferLE(BigInt("1"), 8)).toEqual(
+      Buffer.from([1, 0, 0, 0, 0, 0, 0, 0])
+    );
+  });
+
+  it("1 should equal 1n (32 byte)", async () => {
+    expect(toBufferLE(BigInt("1"), 32)).toEqual(
+      Buffer.from(
+        "0100000000000000000000000000000000000000000000000000000000000000",
+        "hex"
+      )
+    );
+  });
+
+  it("0xdead should equal 0xdeadn (6 byte)", async () => {
+    expect(toBufferLE(BigInt("0xdead"), 6)).toEqual(
+      Buffer.from([0xad, 0xde, 0, 0, 0, 0])
+    );
+  });
+
+  it("0xdeadbeef should equal 0xdeadbeef0000000000n (9 byte)", async () => {
+    expect(toBufferLE(BigInt("0xdeadbeef"), 9)).toEqual(
+      Buffer.from([0xef, 0xbe, 0xad, 0xde, 0, 0, 0, 0, 0])
+    );
+  });
+
+  it("0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn (8 byte)", async () => {
+    expect(toBufferLE(BigInt("0xbadc0ffee0ddf00d"), 8)).toEqual(
+      Buffer.from([0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])
+    );
+  });
+
+  it("0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn", async () => {
+    expect(toBufferLE(BigInt("0xbadc0ffee0ddf00ddeadbeef"), 12)).toEqual(
+      Buffer.from([
+        0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba,
+      ])
+    );
+  });
+
+  it("long value should equal long val", async () => {
+    expect(
+      toBufferLE(
+        BigInt("0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef"),
+        24
+      )
+    ).toEqual(
+      Buffer.from([
+        0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba,
+        0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba,
+      ])
+    );
+  });
+});
+
+describe("Try bigint conversion (big endian)", () => {
+  it("0 should equal 0n", () => {
+    expect(toBufferBE(BigInt("0"), 8)).toEqual(
+      Buffer.from([0, 0, 0, 0, 0, 0, 0, 0])
+    );
+  });
+
+  it("1 should equal 1n", async () => {
+    expect(toBufferBE(BigInt("1"), 8)).toEqual(
+      Buffer.from([0, 0, 0, 0, 0, 0, 0, 1])
+    );
+  });
+
+  it("1 should equal 1n (32 byte)", async () => {
+    expect(toBufferBE(BigInt("1"), 32)).toEqual(
+      Buffer.from(
+        "0000000000000000000000000000000000000000000000000000000000000001",
+        "hex"
+      )
+    );
+  });
+
+  it("0xdead should equal 0xdeadn (6 byte)", async () => {
+    expect(toBufferBE(BigInt("0xdead"), 6)).toEqual(
+      Buffer.from([0, 0, 0, 0, 0xde, 0xad])
+    );
+  });
+
+  it("0xdeadbeef should equal 0xdeadbeef0000000000n (9 byte)", async () => {
+    expect(toBufferBE(BigInt("0xdeadbeef"), 9)).toEqual(
+      Buffer.from([0, 0, 0, 0, 0, 0xde, 0xad, 0xbe, 0xef])
+    );
+  });
+
+  it("0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn (8 byte)", async () => {
+    expect(toBufferBE(BigInt("0xbadc0ffee0ddf00d"), 8)).toEqual(
+      Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d])
+    );
+  });
+
+  it("0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn", async () => {
+    expect(toBufferBE(BigInt("0xbadc0ffee0ddf00ddeadbeef"), 12)).toEqual(
+      Buffer.from([
+        0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d, 0xde, 0xad, 0xbe, 0xef,
+      ])
+    );
+  });
+
+  it("long value should equal long val", async () => {
+    expect(
+      toBufferBE(
+        BigInt("0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef"),
+        24
+      )
+    ).toEqual(
+      Buffer.from([
+        0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d, 0xde, 0xad, 0xbe, 0xef,
+        0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d, 0xde, 0xad, 0xbe, 0xef,
+      ])
+    );
+  });
+});

package/src/index.ts

@@ -0,0 +1,215 @@
+// Export robust Buffer/BigInt methods at top level
+import * as conversionUtils from "./conversion/src/ts/index";
+export { conversionUtils };
+
+interface ConverterInterface {
+  toBigInt(buf: Buffer, bigEndian?: boolean): bigint;
+  fromBigInt(num: bigint, buf: Buffer, bigEndian?: boolean): Buffer;
+}
+
+let converter: ConverterInterface;
+export let isNative = false;
+
+if (typeof window === "undefined") {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    converter = require("bindings")("bigint_buffer");
+    isNative = converter !== undefined;
+  } catch (e) {
+    console.warn(
+      "bigint: Failed to load bindings, pure JS will be used (try npm run rebuild?)", e
+    );
+  }
+}
+
+/**
+ * Convert a little-endian buffer into a BigInt.
+ * @param buf The little-endian buffer to convert
+ * @returns A BigInt with the little-endian representation of buf.
+ */
+export function toBigIntLE(buf: Buffer): bigint {
+  if (typeof window !== "undefined" || converter === undefined) {
+    const reversed = Buffer.from(buf);
+    reversed.reverse();
+    const hex = reversed.toString("hex");
+    if (hex.length === 0) {
+      return BigInt(0);
+    }
+    return BigInt(`0x${hex}`);
+  }
+  return converter.toBigInt(buf, false);
+}
+
+export function validateBigIntBuffer(): boolean {
+  try {
+    const test = toBigIntLE(Buffer.from([0x01, 0x00]));
+    return test === BigInt(1);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Convert a big-endian buffer into a BigInt
+ * @param buf The big-endian buffer to convert.
+ * @returns A BigInt with the big-endian representation of buf.
+ */
+export function toBigIntBE(buf: Buffer): bigint {
+  if (typeof window !== "undefined" || converter === undefined) {
+    const hex = buf.toString("hex");
+    if (hex.length === 0) {
+      return BigInt(0);
+    }
+    return BigInt(`0x${hex}`);
+  }
+  return converter.toBigInt(buf, true);
+}
+
+/**
+ * Convert a BigInt to a little-endian buffer.
+ * @param num   The BigInt to convert.
+ * @param width The number of bytes that the resulting buffer should be.
+ * @returns A little-endian buffer representation of num.
+ */
+export function toBufferLE(num: bigint, width: number): Buffer {
+  if (typeof window !== "undefined" || converter === undefined) {
+    const hex = num.toString(16);
+    const buffer = Buffer.from(
+      hex.padStart(width * 2, "0").slice(0, width * 2),
+      "hex"
+    );
+    buffer.reverse();
+    return buffer;
+  }
+  // Allocation is done here, since it is slower using napi in C
+  return converter.fromBigInt(num, Buffer.allocUnsafe(width), false);
+}
+
+/**
+ * Convert a BigInt to a big-endian buffer.
+ * @param num   The BigInt to convert.
+ * @param width The number of bytes that the resulting buffer should be.
+ * @returns A big-endian buffer representation of num.
+ */
+export function toBufferBE(num: bigint, width: number): Buffer {
+  if (typeof window !== "undefined" || converter === undefined) {
+    const hex = num.toString(16);
+    return Buffer.from(hex.padStart(width * 2, "0").slice(0, width * 2), "hex");
+  }
+  return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);
+}
+
+// ========== Conversion Utilities ==========
+
+/**
+ * Convert a bigint to a Buffer with automatic sizing.
+ * Uses big-endian encoding and calculates the minimum buffer size needed.
+ * @param num The bigint to convert
+ * @returns A big-endian Buffer representation
+ */
+export function bigintToBuf(num: bigint): Buffer {
+  if (num < BigInt(0)) {
+    throw new Error("bigintToBuf: negative bigint values are not supported");
+  }
+  if (num === BigInt(0)) {
+    return Buffer.from([0]);
+  }
+  // Calculate the number of bytes needed
+  const hex = num.toString(16);
+  const width = Math.ceil(hex.length / 2);
+  return toBufferBE(num, width);
+}
+
+/**
+ * Convert a Buffer to a bigint.
+ * Assumes big-endian encoding.
+ * @param buf The buffer to convert
+ * @returns A bigint representation of the buffer
+ */
+export function bufToBigint(buf: Buffer): bigint {
+  return toBigIntBE(buf);
+}
+
+/**
+ * Convert a bigint to a hexadecimal string.
+ * @param num The bigint to convert
+ * @returns A hexadecimal string (without '0x' prefix)
+ */
+export function bigintToHex(num: bigint): string {
+  if (num < BigInt(0)) {
+    throw new Error("bigintToHex: negative bigint values are not supported");
+  }
+  const hex = num.toString(16);
+  // Ensure even length for proper byte representation
+  return hex.length % 2 === 0 ? hex : "0" + hex;
+}
+
+/**
+ * Convert a hexadecimal string to a bigint.
+ * @param hex The hexadecimal string (with or without '0x' prefix)
+ * @returns A bigint representation
+ */
+export function hexToBigint(hex: string): bigint {
+  // Remove '0x' prefix if present
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  if (cleanHex.length === 0) {
+    return BigInt(0);
+  }
+  return BigInt(`0x${cleanHex}`);
+}
+
+/**
+ * Convert a bigint to a decimal text string.
+ * @param num The bigint to convert
+ * @returns A decimal string representation
+ */
+export function bigintToText(num: bigint): string {
+  return num.toString(10);
+}
+
+/**
+ * Convert a decimal text string to a bigint.
+ * @param text The decimal string to convert
+ * @returns A bigint representation
+ */
+export function textToBigint(text: string): bigint {
+  if (!text?.trim()) {
+    throw new Error("textToBigint: input string cannot be empty");
+  }
+  try {
+    return BigInt(text);
+  } catch (e) {
+    throw new Error(`textToBigint: invalid decimal string "${text}" ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+
+/**
+ * Convert a bigint to a base64 string.
+ * @param num The bigint to convert
+ * @returns A base64 string representation
+ */
+export function bigintToBase64(num: bigint): string {
+  if (num < BigInt(0)) {
+    throw new Error("bigintToBase64: negative bigint values are not supported");
+  }
+  const buf = bigintToBuf(num);
+  return buf.toString("base64");
+}
+
+/**
+ * Convert a base64 string to a bigint.
+ * @param base64 The base64 string to convert
+ * @returns A bigint representation
+ */
+export function base64ToBigint(base64: string): bigint {
+  if (!base64?.trim()) {
+    throw new Error("base64ToBigint: input string cannot be empty");
+  }
+  // Trim whitespace and validate base64 format (allows padding)
+  const cleaned = base64.trim();
+  if (!/^[A-Za-z0-9+/]+=*$/.test(cleaned)) {
+    throw new Error("base64ToBigint: invalid base64 string format");
+  }
+  const buf = Buffer.from(cleaned, "base64");
+  return bufToBigint(buf);
+}

package/.travis.yml

@@ -1,51 +0,0 @@
-language: node_js
-node_js:
-- node
-- '24'
-sudo : false
-env:
-  global:
-  - DISPLAY=:99.0
-  - secure: SQDlqZZTkrbRW/wYLPgEwFQpkSrs65MiF0JgO+cwSCAG1m0c7EuBTzvttAXzKK+coZXjd2+QJcAOBi6YUP84OdSf31PojIy4/SLuZxuFQa0sGey+8oSDqgMntpSthO9nom0s6u2vB61IVfcRVIUNv5L3J5i5ZIGlKGgC2MIBzsnhx0L//eyh/bLszR27ajCT7RG+pnqpk010eaDtRabOJTtO0C2kbBQoW2SvJIisDsRj5zqVyl03pZJQQAJeseiNlLokucrgitDWENE+tEJ2w1x1yl+901tgU+BIi4iLQTezcSAxnF149U/Nof7LpCba+1Y+PPh1SRpO4100CT6O46qW0O1keVfTmZL/R3ghBM6H0AtV1s48k/XCpHV9CGwxjBHoCN1kKvSO9B1BJuAdlmgobOEdze+X81nilSBhBmYMI1XPLbXqTo2ImfaFeDzveuPJH6+HMCc+8sDlhgLcrOiteAsY8RsI0ngBkutsWWv7QcRq29e4VX2eBy0j1VJZNf0FPAcKpWF8eIaPw7Z0CuWMs2hM0v0ns58jDcOL+1k4kKyJ10OOmANqNX+NZYRJJ05dd/VMrlh37teARI64PFSG6eIoCniW0GtrUcpX4KhqpaRSUDpsKvncXNdNydumMyMQjeQqyHqahvIE2ONVXXELD2T/EV6TpazDR5KSSo0=
-  - secure: ZwKAlaNZ8liLknkAfFN+TztrILi8Q06AknHUj0Zd+9PjzD5n6tpzp5g1nE0MEvF9bqkGkwf6vwWJVKcSXWM9J4a2pfoLe9wsVcjq+AkmWnZG0zV26ie3UPoa8d/PezRtxz+4vErvQcOqnESVPJAqeWCt0fH1WvnEcjaY3BYyyDbWwAPamWr/v9c4ZLKxJqJmgtczMCrRahd6Dz+HGGJ9BehhOXtse+rT5qFI6w2SMXaisDzk2twMu0fK1I66G2IsesIKErPigCeEPahsP2yu831+S18YvxJtao7tXpluMBf+RNhD9eI1evUu6IxpF419ANDJ7BpJ8uGfRVzIz9kQIAmcy/1s7g3otT633XngUfNYDisUeLJ39plclOHw+sVeLL49Xa9k+/U0CzlOThNlCj0hY2uJW3Ot9NjvKDjdR/UkgEBCl6nIDAnRQk9xSJ4ws1f9Yp5CgEXcXvu7077i6O8vG7+k08qHDSkxEEwQjB2PwjhcPfg9ieAwafblM3szYwzblL4UpROp/L/XmmzjR/cOVrS93RIpeLqDr2CCMKGd0GoOFtDse7u43SJMIAZ+O5DNtNpqIQ22V13p4P3L2C1RV3cjE55luEYVR1JZ7AzaxD+hZu2zcU2301MuSgFLTKMEu43HV1tPJ6QtCcSf+kH/LK/TPfTLveW23xkkZM0=
-  matrix:
-  - TEST_SUITE=test:node
-addons:
-  chrome: stable
-services:
-  - xvfb
-cache:
-  directories:
-   - $HOME/.pnpm
-matrix:
-  fast_finish: true
-  include:
-  - os: linux
-    node_js: '24'
-    env: TEST_SUITE=test:browser
-  - os: windows
-    node_js: '24'
-    env: TEST_SUITE=test:node
-script: pnpm run $TEST_SUITE
-before_deploy:
-- pnpm pack
-deploy:
-- provider: releases
-  api_key: "$GITHUB_TOKEN"
-  file_glob: true
-  file: bigint-buffer-*.tgz
-  skip_cleanup: true
-  on:
-    branch: main
-    node: '10'
-    condition: "$TEST_SUITE = test:node"
-    tags: true
-- provider: npm
-  api_key: "$NPM_TOKEN"
-  skip_cleanup: true
-  email: gsknnft@gmail.com
-  on:
-    branch: main
-    node: '24'
-    condition: "$TEST_SUITE = test:node"
-    tags: true

package/PR_TEMPLATE.md

@@ -1,53 +0,0 @@
-
----
-
-## 📑 PR Template (PULL_REQUEST_TEMPLATE.md)
-
-```markdown
-# Pull Request for @diamondprotocol/bigint-buffer
-
-Thank you for contributing to **@diamondprotocol/bigint-buffer**! Please fill out the details below.
-
----
-
-## 📋 What does this PR do?
-
-<!--
-  - Security fix? (describe vulnerability/CVE)
-  - Feature addition? (describe feature, reason, protocol impact)
-  - Bug fix? (link to test/issue)
-  - CI/test/benchmark improvements?
-  - Documentation or README changes?
--->
-
----
-
-## 🚦 Security & Breaking Change Checklist
-
-- [ ] I have **added or updated tests** for this change.
-- [ ] I have **run all test suites** and verified that everything passes.
-- [ ] If changing buffer size limits or any protocol-relevant logic:
-  - [ ] I have documented the reason and added a warning in README.
-- [ ] I have included reference(s) to any relevant CVEs or advisories.
-
----
-
-## 💬 Additional Notes
-
-<!--
-  - Did you check compatibility with Solana, Jito, Vera, or protocol X?
-  - Is there any API break?
-  - Link to related issues, discussions, or upstream PRs if any.
--->
-
----
-
-## 🔗 Related Links
-
-- [bigint-buffer on npm](https://www.npmjs.com/package/bigint-buffer)
-- [Original repo](https://github.com/no2chem/bigint-buffer)
-- [Current security advisory](https://github.com/advisories/GHSA-3gc7-fjrx-p6mg)
-
----
-
-*Thank you for helping keep supply-chain infra safe and strong!*