@arkecosystem/typescript-crypto 0.0.16 → 0.0.18

package/tests/unit/utils/TransactionTypeIdentifier.test.ts

@@ -0,0 +1,199 @@
+import { jest } from "@jest/globals";
+import { TransactionTypeIdentifier } from "@/utils/TransactionTypeIdentifier";
+import { ConsensusContract, MultipaymentContract, UsernamesContract } from "@/utils/Abi/json";
+import { Helpers } from "@/utils/Helpers";
+
+describe("TransactionTypeIdentifier", () => {
+	const TransactionFunctionSigs = {
+		MultiPayment: MultipaymentContract.methodIdentifiers["pay(address[],uint256[])"],
+		RegisterUsername: UsernamesContract.methodIdentifiers["registerUsername(string)"],
+		ResignUsername: UsernamesContract.methodIdentifiers["resignUsername()"],
+		RegisterValidator: ConsensusContract.methodIdentifiers["registerValidator(bytes)"],
+		ResignValidator: ConsensusContract.methodIdentifiers["resignValidator()"],
+		Vote: ConsensusContract.methodIdentifiers["vote(address)"],
+		Unvote: ConsensusContract.methodIdentifiers["unvote()"],
+		UpdateValidator: ConsensusContract.methodIdentifiers["updateValidator(bytes)"],
+	};
+
+	const InvalidFunctionSignature = "0x1234567";
+
+	beforeAll(() => {
+		jest.mock("@/utils/AbiDecoder", () => {
+			return {
+				AbiDecoder: jest.fn().mockImplementation(() => ({
+					decodeFunctionData: jest.fn().mockReturnValue({ functionName: "transfer" }),
+				})),
+			};
+		});
+	});
+
+	afterAll(() => {
+		jest.clearAllMocks();
+	});
+
+	describe("#isTransfer", () => {
+		it("should return true for empty transfer string", () => {
+			expect(TransactionTypeIdentifier.isTransfer("")).toBe(true);
+		});
+
+		it("should return false for non-empty data", () => {
+			expect(TransactionTypeIdentifier.isTransfer(InvalidFunctionSignature)).toBe(false);
+		});
+	});
+
+	describe("#isVote", () => {
+		it("should return true for matching vote signature", () => {
+			expect(TransactionTypeIdentifier.isVote(Helpers.addLeadingHexZero(TransactionFunctionSigs.Vote))).toBe(
+				true,
+			);
+		});
+
+		it("should return true for matching vote signature without 0x prefix", () => {
+			expect(TransactionTypeIdentifier.isVote(TransactionFunctionSigs.Vote)).toBe(true);
+		});
+
+		it("should return false for non-matching signature", () => {
+			expect(TransactionTypeIdentifier.isVote(InvalidFunctionSignature)).toBe(false);
+		});
+	});
+
+	describe("#isUnvote", () => {
+		it("should return true for matching unvote signature", () => {
+			expect(TransactionTypeIdentifier.isUnvote(Helpers.addLeadingHexZero(TransactionFunctionSigs.Unvote))).toBe(
+				true,
+			);
+		});
+
+		it("should return true for matching unvote signature without 0x prefix", () => {
+			expect(TransactionTypeIdentifier.isUnvote(TransactionFunctionSigs.Unvote)).toBe(true);
+		});
+
+		it("should return false for non-matching signature", () => {
+			expect(TransactionTypeIdentifier.isUnvote(InvalidFunctionSignature)).toBe(false);
+		});
+	});
+
+	describe("#isMultiPayment", () => {
+		it("should return true for matching multi-payment signature", () => {
+			expect(
+				TransactionTypeIdentifier.isMultiPayment(
+					Helpers.addLeadingHexZero(TransactionFunctionSigs.MultiPayment),
+				),
+			).toBe(true);
+		});
+
+		it("should return true for matching multi-payment signature without 0x prefix", () => {
+			expect(TransactionTypeIdentifier.isMultiPayment(TransactionFunctionSigs.MultiPayment)).toBe(true);
+		});
+
+		it("should return false for non-matching signature", () => {
+			expect(TransactionTypeIdentifier.isMultiPayment(InvalidFunctionSignature)).toBe(false);
+		});
+	});
+
+	describe("#isUsernameRegistration", () => {
+		it("should return true for matching registration signature", () => {
+			expect(
+				TransactionTypeIdentifier.isUsernameRegistration(
+					Helpers.addLeadingHexZero(TransactionFunctionSigs.RegisterUsername),
+				),
+			).toBe(true);
+		});
+
+		it("should return true for matching registration signature without 0x prefix", () => {
+			expect(TransactionTypeIdentifier.isUsernameRegistration(TransactionFunctionSigs.RegisterUsername)).toBe(
+				true,
+			);
+		});
+
+		it("should return false for non-matching signature", () => {
+			expect(TransactionTypeIdentifier.isUsernameRegistration(InvalidFunctionSignature)).toBe(false);
+		});
+	});
+
+	describe("#isUsernameResignation", () => {
+		it("should return true for matching resignation signature", () => {
+			expect(
+				TransactionTypeIdentifier.isUsernameResignation(
+					Helpers.addLeadingHexZero(TransactionFunctionSigs.ResignUsername),
+				),
+			).toBe(true);
+		});
+
+		it("should return true for matching resignation signature without 0x prefix", () => {
+			expect(TransactionTypeIdentifier.isUsernameResignation(TransactionFunctionSigs.ResignUsername)).toBe(true);
+		});
+
+		it("should return false for non-matching signature", () => {
+			expect(TransactionTypeIdentifier.isUsernameResignation(InvalidFunctionSignature)).toBe(false);
+		});
+	});
+
+	describe("#isValidatorRegistration", () => {
+		it("should return true for matching validator registration signature", () => {
+			expect(
+				TransactionTypeIdentifier.isValidatorRegistration(
+					Helpers.addLeadingHexZero(TransactionFunctionSigs.RegisterValidator),
+				),
+			).toBe(true);
+		});
+
+		it("should return true for matching validator registration signature without 0x prefix", () => {
+			expect(TransactionTypeIdentifier.isValidatorRegistration(TransactionFunctionSigs.RegisterValidator)).toBe(
+				true,
+			);
+		});
+
+		it("should return false for non-matching signature", () => {
+			expect(TransactionTypeIdentifier.isValidatorRegistration(InvalidFunctionSignature)).toBe(false);
+		});
+	});
+
+	describe("#isValidatorResignation", () => {
+		it("should return true for matching validator resignation signature", () => {
+			expect(
+				TransactionTypeIdentifier.isValidatorResignation(
+					Helpers.addLeadingHexZero(TransactionFunctionSigs.ResignValidator),
+				),
+			).toBe(true);
+		});
+
+		it("should return true for matching validator resignation signature without 0x prefix", () => {
+			expect(TransactionTypeIdentifier.isValidatorResignation(TransactionFunctionSigs.ResignValidator)).toBe(
+				true,
+			);
+		});
+
+		it("should return false for non-matching signature", () => {
+			expect(TransactionTypeIdentifier.isValidatorResignation(InvalidFunctionSignature)).toBe(false);
+		});
+	});
+
+	describe("#isUpdateValidator", () => {
+		it("should return true for matching update validator signature", () => {
+			expect(
+				TransactionTypeIdentifier.isUpdateValidator(
+					Helpers.addLeadingHexZero(TransactionFunctionSigs.UpdateValidator),
+				),
+			).toBe(true);
+		});
+
+		it("should return true for matching update validator signature without 0x prefix", () => {
+			expect(TransactionTypeIdentifier.isUpdateValidator(TransactionFunctionSigs.UpdateValidator)).toBe(true);
+		});
+
+		it("should return false for non-matching signature", () => {
+			expect(TransactionTypeIdentifier.isUpdateValidator(InvalidFunctionSignature)).toBe(false);
+		});
+	});
+
+	describe("#isTokenTransfer", () => {
+		it("should return true for valid token transfer data", () => {
+			expect(TransactionTypeIdentifier.isTokenTransfer("0x" + "0".repeat(64))).toBe(false);
+		});
+
+		it("should return false for invalid data", () => {
+			expect(TransactionTypeIdentifier.isTokenTransfer(InvalidFunctionSignature)).toBe(false);
+		});
+	});
+});