feat: big number support for cbor

Author: kuhe

packages/core/src/submodules/cbor/cbor-decode.ts

@@ -119,11 +119,34 @@ export function decode(at: Uint32, to: Uint32): CborValueType {
         _offset = offset;
         return castBigInt(negativeInt);
       } else {
-        const value = decode(at + offset, to);
-        const valueOffset = _offset;
+        if (minor === 2) {
+          const length = decode(at + offset, to);
+          const valueOffset = _offset;
+          _offset = offset + valueOffset;
+
+          const bigIntBytes = payload.slice(at + valueOffset, at + valueOffset + length);
+
+          console.log({
+            length,
+            bytes: Uint8Array.from(bigIntBytes),
+          });
+
+          let b = BigInt(0);
+          for (let i = bigIntBytes.length - 1; i >= 0; --i) {
+            b = (b << BigInt(8)) | BigInt(bigIntBytes[i]);
+          }
+
+          return b;
+        } else if (minor === 3) {
+          return BigInt(3);
+        } else {
+          const value = decode(at + offset, to);
+          const valueOffset = _offset;
+
+          _offset = offset + valueOffset;
 
-        _offset = offset + valueOffset;
-        return tag({ tag: castBigInt(unsignedInt), value });
+          return tag({ tag: castBigInt(unsignedInt), value });
+        }
       }
     case majorUtf8String:
     case majorMap:

packages/core/src/submodules/cbor/cbor-encode.ts

@@ -1,6 +1,7 @@
 import { fromUtf8 } from "@smithy/util-utf8";
 
 import {
+  alloc,
   CborMajorType,
   extendedFloat16,
   extendedFloat32,
@@ -19,7 +20,6 @@ import {
   tagSymbol,
   Uint64,
 } from "./cbor-types";
-import { alloc } from "./cbor-types";
 
 const USE_BUFFER = typeof Buffer !== "undefined";
 
@@ -152,10 +152,30 @@ export function encode(_input: any): void {
         data[cursor++] = (major << 5) | extendedFloat32;
         dataView.setUint32(cursor, n);
         cursor += 4;
-      } else {
+      } else if (n < BigInt("18446744073709551616")) {
         data[cursor++] = (major << 5) | extendedFloat64;
         dataView.setBigUint64(cursor, value);
         cursor += 8;
+      } else {
+        // refer to https://www.rfc-editor.org/rfc/rfc8949.html#name-bignums
+        const binaryBigInt = input.toString(2);
+        const bigIntBytes = new Uint8Array(Math.ceil(binaryBigInt.length / 8));
+        let b = input;
+        let i = 0;
+        while (bigIntBytes.byteLength - ++i >= 0) {
+          bigIntBytes[bigIntBytes.byteLength - i] = Number(b & BigInt(255));
+          b >>= BigInt(8);
+        }
+        ensureSpace(bigIntBytes.byteLength * 2);
+        data[cursor++] = nonNegative ? 0b110_00010 : 0b110_00011;
+
+        if (USE_BUFFER) {
+          encodeHeader(majorUtf8String, Buffer.byteLength(bigIntBytes));
+        } else {
+          encodeHeader(majorUtf8String, bigIntBytes.byteLength);
+        }
+        data.set(bigIntBytes, cursor);
+        cursor += bigIntBytes.byteLength;
       }
       continue;
     } else if (input === null) {

packages/core/src/submodules/cbor/cbor.spec.ts

@@ -226,6 +226,18 @@ describe("cbor", () => {
   };
 
   describe("locally curated scenarios", () => {
+    it.only("should round-trip bigInteger to major 6 with tag 2 or tag 3", () => {
+      const bigInt = BigInt("1".repeat(100));
+      const serialized = cbor.serialize(bigInt);
+
+      const major = serialized[0] >> 5;
+
+      const deserialized = cbor.deserialize(serialized);
+      expect(deserialized).toEqual(bigInt);
+    });
+
+    it("should round-trip NumericValue to major 6 with tag 4", () => {});
+
     it("should throw an error if serializing a tag with missing properties", () => {
       expect(() =>
         cbor.serialize({