Add utility method to test register type

Fixes #122

.changeset/silly-knives-retire.md

@@ -0,0 +1,5 @@
+---
+"@fleet-sdk/serializer": minor
+---
+
+Introduce `stypeof` utility function

packages/serializer/src/index.ts

@@ -1,4 +1,4 @@
 export { estimateVLQSize, SigmaByteReader, SigmaByteWriter } from "./coders";
-export { SConstant, parse, decode } from "./sigmaConstant";
+export { SConstant, parse, decode, stypeof } from "./sigmaConstant";
 export * from "./types";
 export * from "./serializers";

packages/serializer/src/sigmaConstant.spec.ts

@@ -15,7 +15,7 @@ import {
 } from "./_test-vectors/constantVectors";
 import { SigmaByteWriter } from "./coders";
 import { dataSerializer } from "./serializers";
-import { decode, parse, SConstant } from "./sigmaConstant";
+import { decode, parse, SConstant, stypeof } from "./sigmaConstant";
 import type { SGroupElementType } from "./types";
 import {
   SBigInt,
@@ -27,6 +27,7 @@ import {
   SLong,
   SShort,
   SSigmaProp,
+  STupleType,
   SUnit
 } from "./types/";
 import { STuple } from "./types/constructors";
@@ -144,6 +145,32 @@ describe("SColl serialization and parsing", () => {
   });
 });
 
+describe("stypeof", () => {
+  it("Should return the type of a valid constant", () => {
+    expect(stypeof(SBool(true).toBytes())).to.be.instanceOf(SBool);
+    expect(stypeof(SByte(1).toBytes())).to.be.instanceOf(SByte);
+    expect(stypeof(SShort(1).toBytes())).to.be.instanceOf(SShort);
+    expect(stypeof(SInt(1).toBytes())).to.be.instanceOf(SInt);
+    expect(stypeof(SLong(1n).toBytes())).to.be.instanceOf(SLong);
+    expect(stypeof(SBigInt(1n).toBytes())).to.be.instanceOf(SBigInt);
+    expect(stypeof(SGroupElement(hex.decode("deadbeef")).toBytes())).to.be.instanceOf(
+      SGroupElement
+    );
+    expect(stypeof(SSigmaProp(SGroupElement("deadbeef")).toBytes())).to.be.instanceOf(
+      SSigmaProp
+    );
+    expect(stypeof(SColl(SByte, [1, 2, 3]).toBytes())).to.be.instanceOf(SColl);
+    expect(stypeof(STuple(SByte(1), SByte(2)).toBytes())).to.be.instanceOf(STupleType);
+    expect(stypeof(SUnit().toBytes())).to.be.instanceOf(SUnit);
+  });
+
+  it("Should return SUnit for empty bytes", () => {
+    expect(stypeof(Uint8Array.from([]))).to.be.equal(undefined);
+    expect(stypeof(undefined)).to.be.equal(undefined);
+    expect(stypeof("deadbeef")).to.be.equal(undefined);
+  });
+});
+
 describe("Safe decoding", () => {
   const validVectors = [
     { hex: "40050002", data: [0, 1n], type: "(SInt, SLong)" },

packages/serializer/src/sigmaConstant.ts

@@ -67,6 +67,23 @@ export function decode<D = unknown, T extends SType = SType>(
   }
 }
 
+/**
+ * Returns the `SType` of the given value.
+ *
+ * @param value - The value to check the SType of.
+ * @returns The SType of the value, or `undefined` if the value is `undefined` or
+ * deserialization fails.
+ */
+export function stypeof(value?: ByteInput): SType | undefined {
+  if (!value) return;
+
+  try {
+    return typeSerializer.deserialize(new SigmaByteReader(value));
+  } catch {
+    return;
+  }
+}
+
 /** @deprecated use `decode` instead */
 export function parse<T>(constant: ByteInput): T;
 /** @deprecated use `decode` instead */