@arkecosystem/typescript-crypto 0.0.17 → 0.0.18

package/dist/index.js

@@ -28336,6 +28336,56 @@ var TransactionDataEncoder = class {
   }
 };
 
+// src/utils/TransactionTypeIdentifier.ts
+var TransactionFunctionSigs = {
+  MultiPayment: Abi_Multipayment_default.methodIdentifiers["pay(address[],uint256[])"],
+  RegisterUsername: Abi_Usernames_default.methodIdentifiers["registerUsername(string)"],
+  ResignUsername: Abi_Usernames_default.methodIdentifiers["resignUsername()"],
+  Transfer: "",
+  RegisterValidator: Abi_Consensus_default.methodIdentifiers["registerValidator(bytes)"],
+  ResignValidator: Abi_Consensus_default.methodIdentifiers["resignValidator()"],
+  Vote: Abi_Consensus_default.methodIdentifiers["vote(address)"],
+  Unvote: Abi_Consensus_default.methodIdentifiers["unvote()"],
+  UpdateValidator: Abi_Consensus_default.methodIdentifiers["updateValidator(bytes)"]
+};
+var TransactionTypeIdentifier = class {
+  static isTransfer(data) {
+    return data === TransactionFunctionSigs.Transfer;
+  }
+  static isVote(data) {
+    return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.Vote);
+  }
+  static isUnvote(data) {
+    return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.Unvote);
+  }
+  static isMultiPayment(data) {
+    return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.MultiPayment);
+  }
+  static isUsernameRegistration(data) {
+    return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.RegisterUsername);
+  }
+  static isUsernameResignation(data) {
+    return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.ResignUsername);
+  }
+  static isValidatorRegistration(data) {
+    return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.RegisterValidator);
+  }
+  static isValidatorResignation(data) {
+    return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.ResignValidator);
+  }
+  static isUpdateValidator(data) {
+    return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.UpdateValidator);
+  }
+  static isTokenTransfer(data) {
+    try {
+      const decodedData = new AbiDecoder("token" /* TOKEN */).decodeFunctionData(data);
+      return decodedData.functionName === "transfer";
+    } catch {
+    }
+    return false;
+  }
+};
+
 // src/transactions/builders/TokenTransferBuilder.ts
 var TokenTransferBuilder = class extends AbstractTransactionBuilder {
   constructor(data) {
@@ -28762,6 +28812,8 @@ export {
   Abi_Token_default as TokenContract,
   TokenTransferBuilder,
   TransactionDataEncoder,
+  TransactionFunctionSigs,
+  TransactionTypeIdentifier,
   TransactionUtils,
   Transfer,
   TransferBuilder,

package/dist/utils/TransactionTypeIdentifier.d.ts

@@ -0,0 +1,24 @@
+export declare const TransactionFunctionSigs: {
+    MultiPayment: string;
+    RegisterUsername: string;
+    ResignUsername: string;
+    Transfer: string;
+    RegisterValidator: string;
+    ResignValidator: string;
+    Vote: string;
+    Unvote: string;
+    UpdateValidator: string;
+};
+export declare class TransactionTypeIdentifier {
+    static isTransfer(data: string): boolean;
+    static isVote(data: string): boolean;
+    static isUnvote(data: string): boolean;
+    static isMultiPayment(data: string): boolean;
+    static isUsernameRegistration(data: string): boolean;
+    static isUsernameResignation(data: string): boolean;
+    static isValidatorRegistration(data: string): boolean;
+    static isValidatorResignation(data: string): boolean;
+    static isUpdateValidator(data: string): boolean;
+    static isTokenTransfer(data: string): boolean;
+}
+//# sourceMappingURL=TransactionTypeIdentifier.d.ts.map

package/dist/utils/TransactionTypeIdentifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionTypeIdentifier.d.ts","sourceRoot":"","sources":["../../src/utils/TransactionTypeIdentifier.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,uBAAuB;;;;;;;;;;CAUnC,CAAC;AAEF,qBAAa,yBAAyB;WACvB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAIjC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAI7B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAI/B,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAIrC,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAI7C,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAI5C,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAI9C,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAI7C,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;WAIxC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAUpD"}

package/dist/utils/TransactionTypeIdentifier.js

@@ -0,0 +1,54 @@
+import { ContractAbiType } from "@/enums";
+import { AbiDecoder } from "./AbiDecoder";
+import { ConsensusContract, MultipaymentContract, UsernamesContract } from "./Abi/json";
+import { Helpers } from "./Helpers";
+export const TransactionFunctionSigs = {
+    MultiPayment: MultipaymentContract.methodIdentifiers["pay(address[],uint256[])"],
+    RegisterUsername: UsernamesContract.methodIdentifiers["registerUsername(string)"],
+    ResignUsername: UsernamesContract.methodIdentifiers["resignUsername()"],
+    Transfer: "",
+    RegisterValidator: ConsensusContract.methodIdentifiers["registerValidator(bytes)"],
+    ResignValidator: ConsensusContract.methodIdentifiers["resignValidator()"],
+    Vote: ConsensusContract.methodIdentifiers["vote(address)"],
+    Unvote: ConsensusContract.methodIdentifiers["unvote()"],
+    UpdateValidator: ConsensusContract.methodIdentifiers["updateValidator(bytes)"],
+};
+export class TransactionTypeIdentifier {
+    static isTransfer(data) {
+        return data === TransactionFunctionSigs.Transfer;
+    }
+    static isVote(data) {
+        return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.Vote);
+    }
+    static isUnvote(data) {
+        return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.Unvote);
+    }
+    static isMultiPayment(data) {
+        return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.MultiPayment);
+    }
+    static isUsernameRegistration(data) {
+        return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.RegisterUsername);
+    }
+    static isUsernameResignation(data) {
+        return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.ResignUsername);
+    }
+    static isValidatorRegistration(data) {
+        return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.RegisterValidator);
+    }
+    static isValidatorResignation(data) {
+        return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.ResignValidator);
+    }
+    static isUpdateValidator(data) {
+        return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.UpdateValidator);
+    }
+    static isTokenTransfer(data) {
+        try {
+            const decodedData = new AbiDecoder(ContractAbiType.TOKEN).decodeFunctionData(data);
+            return decodedData.functionName === "transfer";
+        }
+        catch (_a) {
+            // Different abi type. Ignore.
+        }
+        return false;
+    }
+}

package/dist/utils/index.d.ts

@@ -7,4 +7,5 @@ export * from "./Slot";
 export * from "./TransactionUtils";
 export * from "./UnitConverter";
 export * from "./TransactionDataEncoder";
+export * from "./TransactionTypeIdentifier";
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC"}

package/dist/utils/index.js

@@ -7,3 +7,4 @@ export * from "./Slot";
 export * from "./TransactionUtils";
 export * from "./UnitConverter";
 export * from "./TransactionDataEncoder";
+export * from "./TransactionTypeIdentifier";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkecosystem/typescript-crypto",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "engines": {
     "node": ">=20.12.2"
   },

package/src/utils/TransactionTypeIdentifier.ts

@@ -0,0 +1,65 @@
+import { ContractAbiType } from "@/enums";
+import { AbiDecoder } from "./AbiDecoder";
+import { ConsensusContract, MultipaymentContract, UsernamesContract } from "./Abi/json";
+import { Helpers } from "./Helpers";
+
+export const TransactionFunctionSigs = {
+	MultiPayment: MultipaymentContract.methodIdentifiers["pay(address[],uint256[])"],
+	RegisterUsername: UsernamesContract.methodIdentifiers["registerUsername(string)"],
+	ResignUsername: UsernamesContract.methodIdentifiers["resignUsername()"],
+	Transfer: "",
+	RegisterValidator: ConsensusContract.methodIdentifiers["registerValidator(bytes)"],
+	ResignValidator: ConsensusContract.methodIdentifiers["resignValidator()"],
+	Vote: ConsensusContract.methodIdentifiers["vote(address)"],
+	Unvote: ConsensusContract.methodIdentifiers["unvote()"],
+	UpdateValidator: ConsensusContract.methodIdentifiers["updateValidator(bytes)"],
+};
+
+export class TransactionTypeIdentifier {
+	public static isTransfer(data: string): boolean {
+		return data === TransactionFunctionSigs.Transfer;
+	}
+
+	public static isVote(data: string): boolean {
+		return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.Vote);
+	}
+
+	public static isUnvote(data: string): boolean {
+		return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.Unvote);
+	}
+
+	public static isMultiPayment(data: string): boolean {
+		return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.MultiPayment);
+	}
+
+	public static isUsernameRegistration(data: string): boolean {
+		return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.RegisterUsername);
+	}
+
+	public static isUsernameResignation(data: string): boolean {
+		return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.ResignUsername);
+	}
+
+	public static isValidatorRegistration(data: string): boolean {
+		return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.RegisterValidator);
+	}
+
+	public static isValidatorResignation(data: string): boolean {
+		return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.ResignValidator);
+	}
+
+	public static isUpdateValidator(data: string): boolean {
+		return Helpers.removeLeadingHexZero(data).startsWith(TransactionFunctionSigs.UpdateValidator);
+	}
+
+	public static isTokenTransfer(data: string): boolean {
+		try {
+			const decodedData = new AbiDecoder(ContractAbiType.TOKEN).decodeFunctionData(data);
+			return decodedData.functionName === "transfer";
+		} catch {
+			// Different abi type. Ignore.
+		}
+
+		return false;
+	}
+}

package/src/utils/index.ts

@@ -7,3 +7,4 @@ export * from "./Slot";
 export * from "./TransactionUtils";
 export * from "./UnitConverter";
 export * from "./TransactionDataEncoder";
+export * from "./TransactionTypeIdentifier";

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);
+		});
+	});
+});