@arkecosystem/typescript-crypto 0.0.16 → 0.0.18

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

@@ -6,4 +6,6 @@ export * from "./Message";
 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"}
+{"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

@@ -6,3 +6,5 @@ export * from "./Message";
 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.16",
+  "version": "0.0.18",
   "engines": {
     "node": ">=20.12.2"
   },

package/src/enums/AbiFunction.ts

@@ -3,7 +3,9 @@ export enum AbiFunction {
 	UNVOTE = "unvote",
 	VALIDATOR_REGISTRATION = "registerValidator",
 	VALIDATOR_RESIGNATION = "resignValidator",
+	UPDATE_VALIDATOR = "updateValidator",
 	USERNAME_REGISTRATION = "registerUsername",
 	USERNAME_RESIGNATION = "resignUsername",
 	MULTIPAYMENT = "pay",
+	TRANSFER = "transfer",
 }

package/src/transactions/builders/TokenTransferBuilder.ts

@@ -0,0 +1,35 @@
+import { ITokenTransferBuilder, ITransaction, TransactionData } from "@/types";
+
+import { AbstractTransactionBuilder } from "./AbstractTransactionBuilder";
+import { EvmCall } from "@/transactions/types/EvmCall";
+import { Helpers } from "@/utils/Helpers";
+import { AbiEncoder } from "@/utils";
+import { ContractAbiType } from "@/enums";
+
+export class TokenTransferBuilder
+	extends AbstractTransactionBuilder<ITokenTransferBuilder>
+	implements ITokenTransferBuilder
+{
+	public constructor(data?: Record<string, unknown>) {
+		super(data);
+	}
+
+	public static new(data?: Record<string, unknown>): TokenTransferBuilder {
+		return new this(data);
+	}
+
+	public contractAddress(address: string): TokenTransferBuilder {
+		this.transaction.data.to = address;
+		return this;
+	}
+
+	public recipient(address: string, amount: bigint): TokenTransferBuilder {
+		const payload = new AbiEncoder(ContractAbiType.TOKEN).encodeFunctionCall("transfer", [address, amount]);
+		this.transaction.data["data"] = Helpers.removeLeadingHexZero(payload);
+		return this;
+	}
+
+	protected getTransactionInstance(data?: Record<string, unknown>): ITransaction {
+		return new EvmCall(data as TransactionData);
+	}
+}

package/src/transactions/builders/index.ts

@@ -1,5 +1,6 @@
 export * from "./AbstractTransactionBuilder";
 export * from "./EvmCallBuilder";
+export * from "./TokenTransferBuilder";
 export * from "./MultipaymentBuilder";
 export * from "./TransferBuilder";
 export * from "./UnvoteBuilder";

package/src/types.ts

@@ -1,6 +1,8 @@
 import BigNumber from "bignumber.js";
 import { Result } from "ethers";
 
+export type Hex = `0x${string}`;
+
 export interface TransactionData {
 	gasPrice?: string | null;
 	gasLimit?: string | null;
@@ -81,6 +83,11 @@ export interface IEvmCallBuilder extends ITransactionBuilder<IEvmCallBuilder> {
 	payload(payload: string): IEvmCallBuilder;
 }
 
+export interface ITokenTransferBuilder extends ITransactionBuilder<ITokenTransferBuilder> {
+	recipient(address: string, amount: bigint): ITokenTransferBuilder;
+	contractAddress(address: string): ITokenTransferBuilder;
+}
+
 export interface IMultipaymentBuilder extends ITransactionBuilder<IMultipaymentBuilder> {
 	pay(address: string, amount: string | BigNumber): IMultipaymentBuilder;
 }

package/src/utils/AbiEncoder.ts

@@ -1,3 +1,4 @@
+import { Hex } from "@/types";
 import { AbiBase } from "./AbiBase";
 import { Helpers } from "./Helpers";
 
@@ -5,4 +6,8 @@ export class AbiEncoder extends AbiBase {
 	encodeFunctionCall(functionName: string, parameters: unknown[]): string {
 		return Helpers.removeLeadingHexZero(this.interface.encodeFunctionData(functionName, parameters));
 	}
+
+	encodeFunctionCallHex(functionName: string, parameters: unknown[]): Hex {
+		return this.interface.encodeFunctionData(functionName, parameters) as Hex;
+	}
 }

package/src/utils/Helpers.ts

@@ -1,4 +1,5 @@
 import { InvalidUsernameException } from "@/exceptions/InvalidUsernameException";
+import { Hex } from "@/types";
 
 export class Helpers {
 	/**
@@ -43,4 +44,18 @@ export class Helpers {
 	public static removeLeadingHexZero(hex: string): string {
 		return hex.replace(/^0x/, ""); // Using replace to only remove the prefix, not leading zeros
 	}
+
+	/**
+	 * Adds the leading '0x' to a string.
+	 *
+	 * @param string the input without `0x`
+	 * @returns the hex output with the leading `0x`
+	 */
+	public static addLeadingHexZero(input: string): Hex {
+		if (input.startsWith("0x")) {
+			return input as Hex;
+		}
+
+		return `0x${input}`;
+	}
 }

package/src/utils/TransactionDataEncoder.ts

@@ -0,0 +1,54 @@
+import { AbiFunction, ContractAbiType } from "@/enums";
+import { AbiEncoder } from "./AbiEncoder";
+import { Hex } from "@/types";
+import { Helpers } from "./Helpers";
+
+export class TransactionDataEncoder {
+	public static multiPayment(recipients: string[], amounts: string[]): Hex {
+		return new AbiEncoder(ContractAbiType.MULTIPAYMENT).encodeFunctionCallHex(AbiFunction.MULTIPAYMENT, [
+			recipients,
+			amounts,
+		]);
+	}
+
+	public static updateValidator(validatorPublicKey: string): Hex {
+		return new AbiEncoder(ContractAbiType.CONSENSUS).encodeFunctionCallHex(AbiFunction.UPDATE_VALIDATOR, [
+			Helpers.addLeadingHexZero(validatorPublicKey),
+		]);
+	}
+
+	public static usernameRegistration(username: string): Hex {
+		return new AbiEncoder(ContractAbiType.USERNAMES).encodeFunctionCallHex(AbiFunction.USERNAME_REGISTRATION, [
+			username,
+		]);
+	}
+
+	public static usernameResignation(): Hex {
+		return new AbiEncoder(ContractAbiType.USERNAMES).encodeFunctionCallHex(AbiFunction.USERNAME_RESIGNATION, []);
+	}
+
+	public static validatorRegistration(validatorPublicKey: string): Hex {
+		return new AbiEncoder(ContractAbiType.CONSENSUS).encodeFunctionCallHex(AbiFunction.VALIDATOR_REGISTRATION, [
+			Helpers.addLeadingHexZero(validatorPublicKey),
+		]);
+	}
+
+	public static validatorResignation(): Hex {
+		return new AbiEncoder(ContractAbiType.CONSENSUS).encodeFunctionCallHex(AbiFunction.VALIDATOR_RESIGNATION, []);
+	}
+
+	public static tokenTransfer(recipientAddress: string, amount: string): Hex {
+		return new AbiEncoder(ContractAbiType.TOKEN).encodeFunctionCallHex(AbiFunction.TRANSFER, [
+			recipientAddress,
+			amount,
+		]);
+	}
+
+	public static vote(voteAddress: string): Hex {
+		return new AbiEncoder(ContractAbiType.CONSENSUS).encodeFunctionCallHex(AbiFunction.VOTE, [voteAddress]);
+	}
+
+	public static unvote(): Hex {
+		return new AbiEncoder(ContractAbiType.CONSENSUS).encodeFunctionCallHex(AbiFunction.UNVOTE, []);
+	}
+}

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

@@ -6,3 +6,5 @@ export * from "./Message";
 export * from "./Slot";
 export * from "./TransactionUtils";
 export * from "./UnitConverter";
+export * from "./TransactionDataEncoder";
+export * from "./TransactionTypeIdentifier";

package/tests/fixtures/transactions/token-transfer.json

@@ -0,0 +1,16 @@
+{
+	"data": {
+		"value": "0",
+		"senderPublicKey": "0243333347c8cbf4e3cbc7a96964181d02a2b0c854faa2fef86b4b8d92afcf473d",
+		"gasPrice": "5000000000",
+		"gasLimit": "21000",
+		"nonce": "1",
+		"data": "a9059cbb0000000000000000000000006f0182a0cc707b055322ccf6d4cb6a5aff1aeb220000000000000000000000000000000000000000000000000000000000000000",
+		"to": "0x6F0182a0cc707b055322CcF6d4CB6a5Aff1aEb22",
+		"v": 0,
+		"r": "ca5516c582647a1626bfeb4ccf62314dae02c8c561dbff690bdbda89d181e6f7",
+		"s": "1b4ddf55e432e532c8e8d1a854f21e0c80e35a35fe4557899fb3f485d071f1e1",
+		"hash": "4bb567e6ffd6716b99865fc6917eadf0f5b6cbccdd6999a592db6143a7f24d81"
+	},
+	"serialized": "f8ab0185012a05f200825208946f0182a0cc707b055322ccf6d4cb6a5aff1aeb2280b844a9059cbb0000000000000000000000006f0182a0cc707b055322ccf6d4cb6a5aff1aeb220000000000000000000000000000000000000000000000000000000000000000825c6ba0ca5516c582647a1626bfeb4ccf62314dae02c8c561dbff690bdbda89d181e6f7a01b4ddf55e432e532c8e8d1a854f21e0c80e35a35fe4557899fb3f485d071f1e1"
+}

package/tests/fixtures/transactions/transaction-data-encoder.json

@@ -0,0 +1,15 @@
+{
+	"Username": "test",
+	"Address": "0xA5cc0BfEB09742C5e4C610f2EBaaB82Eb142Ca10",
+	"ValidatorPublicKey": "b209f4a7454ae17c5808991dffbf204c747b851f351d2ce72a6e18903d0e2f609e0328ebbc3fb97cd4d3660b4bc156f1",
+	"Amount": "1000000000000",
+	"Encoded": {
+		"UpdateValidator": "0x5a8eed7300000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000030b209f4a7454ae17c5808991dffbf204c747b851f351d2ce72a6e18903d0e2f609e0328ebbc3fb97cd4d3660b4bc156f100000000000000000000000000000000",
+		"UsernameRegistration": "0x36a94134000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000047465737400000000000000000000000000000000000000000000000000000000",
+		"UsernameResignation": "0xebed6dab",
+		"ValidatorRegistration": "0x602a9eee00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000030b209f4a7454ae17c5808991dffbf204c747b851f351d2ce72a6e18903d0e2f609e0328ebbc3fb97cd4d3660b4bc156f100000000000000000000000000000000",
+		"ValidatorResignation": "0xb85f5da2",
+		"TokenTransfer": "0xa9059cbb000000000000000000000000a5cc0bfeb09742c5e4c610f2ebaab82eb142ca10000000000000000000000000000000000000000000000000000000e8d4a51000",
+		"MultiPayment": "0x084ce708000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc0bfeb09742c5e4c610f2ebaab82eb142ca10000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000003e8"
+	}
+}

package/tests/unit/transactions/builders/TokenTransferBuilder.test.ts

@@ -0,0 +1,138 @@
+import { TokenTransferBuilder } from "@/transactions/builders/TokenTransferBuilder";
+import identityFixture from "@tests/fixtures/identity.json";
+import fixture from "@tests/fixtures/transactions/token-transfer.json";
+
+it("should build a token transfer", async () => {
+	const transaction = (
+		await TokenTransferBuilder.new()
+			.recipient(fixture.data.to, BigInt(fixture.data.value))
+			.to(fixture.data.to)
+			.nonce(fixture.data.nonce)
+			.gasPrice(fixture.data.gasPrice)
+			.gasLimit(fixture.data.gasLimit)
+			.sign(identityFixture.passphrase)
+	).transaction;
+
+	expect(transaction.data.gasPrice).toBe(fixture.data.gasPrice);
+	expect(transaction.data.nonce).toBe(fixture.data.nonce);
+	expect(transaction.data.gasLimit).toBe(fixture.data.gasLimit);
+	expect(transaction.data.value).toBe("0");
+	expect(transaction.data.v).toBe(fixture.data.v);
+	expect(transaction.data.r).toBe(fixture.data.r);
+	expect(transaction.data.s).toBe(fixture.data.s);
+	expect(transaction.data.hash).toBe(fixture.data.hash);
+
+	expect(transaction.serialize().toString("hex")).toEqual(fixture.serialized);
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should sign a token transfer", async () => {
+	const { transaction } = await TokenTransferBuilder.new()
+		.recipient(fixture.data.to, BigInt(fixture.data.value))
+		.to(fixture.data.to)
+		.nonce(fixture.data.nonce)
+		.gasPrice(fixture.data.gasPrice)
+		.gasLimit(fixture.data.gasLimit)
+		.sign(identityFixture.passphrase);
+
+	expect(transaction.data.gasPrice).toBe(fixture.data.gasPrice);
+	expect(transaction.data.nonce).toBe(fixture.data.nonce);
+	expect(transaction.data.gasLimit).toBe(fixture.data.gasLimit);
+	expect(transaction.data.to).toBe(fixture.data.to);
+	expect(transaction.data.value).toBe(fixture.data.value);
+	expect(transaction.data.v).toBe(fixture.data.v);
+	expect(transaction.data.r).toBe(fixture.data.r);
+	expect(transaction.data.s).toBe(fixture.data.s);
+	expect(transaction.data.hash).toBe(fixture.data.hash);
+
+	expect(transaction.serialize().toString("hex")).toEqual(fixture.serialized);
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should verify", async () => {
+	const transaction = await TokenTransferBuilder.new()
+		.recipient(fixture.data.to, BigInt(fixture.data.value))
+		.to(fixture.data.to)
+		.nonce(fixture.data.nonce)
+		.gasPrice(fixture.data.gasPrice)
+		.gasLimit(fixture.data.gasLimit)
+		.sign(identityFixture.passphrase);
+
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should convert to an array", async () => {
+	const transaction = await TokenTransferBuilder.new()
+		.recipient(fixture.data.to, BigInt(fixture.data.value))
+		.to(fixture.data.to)
+		.nonce(fixture.data.nonce)
+		.gasPrice(fixture.data.gasPrice)
+		.gasLimit(fixture.data.gasLimit)
+		.sign(identityFixture.passphrase);
+
+	expect(transaction.toObject()).toEqual({
+		data: fixture.data.data,
+		to: fixture.data.to,
+		value: fixture.data.value,
+		gasPrice: fixture.data.gasPrice,
+		gasLimit: fixture.data.gasLimit,
+		nonce: fixture.data.nonce,
+		v: fixture.data.v,
+		r: fixture.data.r,
+		s: fixture.data.s,
+		senderPublicKey: fixture.data.senderPublicKey,
+		hash: fixture.data.hash,
+	});
+});
+
+it("should convert to json", async () => {
+	const transaction = await TokenTransferBuilder.new()
+		.recipient(fixture.data.to, BigInt(fixture.data.value))
+		.to(fixture.data.to)
+		.nonce(fixture.data.nonce)
+		.gasPrice(fixture.data.gasPrice)
+		.gasLimit(fixture.data.gasLimit)
+		.sign(identityFixture.passphrase);
+
+	expect(transaction.toJson()).toEqual(
+		JSON.stringify({
+			gasPrice: fixture.data.gasPrice,
+			hash: fixture.data.hash,
+			gasLimit: fixture.data.gasLimit,
+			nonce: fixture.data.nonce,
+			senderPublicKey: fixture.data.senderPublicKey,
+			to: fixture.data.to,
+			value: fixture.data.value,
+			data: fixture.data.data,
+			r: fixture.data.r,
+			s: fixture.data.s,
+			v: fixture.data.v,
+		}),
+	);
+});
+
+it("should convert to string", async () => {
+	const transaction = await TokenTransferBuilder.new()
+		.recipient(fixture.data.to, BigInt(fixture.data.value))
+		.to(fixture.data.to)
+		.nonce(fixture.data.nonce)
+		.gasPrice(fixture.data.gasPrice)
+		.gasLimit(fixture.data.gasLimit)
+		.sign(identityFixture.passphrase);
+
+	expect(transaction.toString()).toEqual(
+		JSON.stringify({
+			gasPrice: fixture.data.gasPrice,
+			hash: fixture.data.hash,
+			gasLimit: fixture.data.gasLimit,
+			nonce: fixture.data.nonce,
+			senderPublicKey: fixture.data.senderPublicKey,
+			to: fixture.data.to,
+			value: fixture.data.value,
+			data: fixture.data.data,
+			r: fixture.data.r,
+			s: fixture.data.s,
+			v: fixture.data.v,
+		}),
+	);
+});

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

@@ -46,3 +46,15 @@ it("should encode using a custom abi", () => {
 
 	expect(encodedData).toBe(expectedEncodedData);
 });
+
+it("should encode a vote function call to hex", () => {
+	const encoder = new AbiEncoder();
+
+	const functionName = "vote";
+	const args = ["0x512F366D524157BcF734546eB29a6d687B762255"];
+	const expectedEncodedData = "6dd7d8ea000000000000000000000000512f366d524157bcf734546eb29a6d687b762255";
+
+	const encodedData = encoder.encodeFunctionCallHex(functionName, args);
+
+	expect(encodedData).toBe(`0x${expectedEncodedData}`);
+});

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

@@ -117,4 +117,14 @@ describe("Helpers", () => {
 			expect(Helpers.removeLeadingHexZero("0X1234")).toBe("0X1234"); // case sensitive
 		});
 	});
+
+	describe("addLeadingHexZero", () => {
+		it("should add the 0x prefix to string", () => {
+			expect(Helpers.addLeadingHexZero("1234")).toBe("0x1234");
+		});
+
+		it("should not add the 0x prefix to string if it has already", () => {
+			expect(Helpers.addLeadingHexZero("0x1234")).toBe("0x1234");
+		});
+	});
 });

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

@@ -0,0 +1,51 @@
+import { TransactionDataEncoder } from "@/utils/TransactionDataEncoder";
+import EncoderFixture from "@tests/fixtures/transactions/transaction-data-encoder.json";
+
+it("should encode multi payment", () => {
+	const encoded = TransactionDataEncoder.multiPayment([EncoderFixture.Address], ["1000"]);
+	expect(encoded).toEqual(EncoderFixture.Encoded.MultiPayment);
+});
+
+it("should encode update validator", () => {
+	const encoded = TransactionDataEncoder.updateValidator(EncoderFixture.ValidatorPublicKey);
+	expect(encoded).toEqual(EncoderFixture.Encoded.UpdateValidator);
+});
+
+it("should encode username registration", () => {
+	const encoded = TransactionDataEncoder.usernameRegistration(EncoderFixture.Username);
+	expect(encoded).toEqual(EncoderFixture.Encoded.UsernameRegistration);
+});
+
+it("should encode username resignation", () => {
+	const encoded = TransactionDataEncoder.usernameResignation();
+	expect(encoded).toEqual(EncoderFixture.Encoded.UsernameResignation);
+});
+
+it("should encode validator registration", () => {
+	const encoded = TransactionDataEncoder.validatorRegistration(EncoderFixture.ValidatorPublicKey);
+	expect(encoded).toEqual(EncoderFixture.Encoded.ValidatorRegistration);
+});
+
+it("should encode validator resignation", () => {
+	const encoded = TransactionDataEncoder.validatorResignation();
+	expect(encoded).toEqual(EncoderFixture.Encoded.ValidatorResignation);
+});
+
+it("should encode token uransfer", () => {
+	const encoded = TransactionDataEncoder.tokenTransfer(EncoderFixture.Address, EncoderFixture.Amount);
+	expect(encoded).toEqual(EncoderFixture.Encoded.TokenTransfer);
+});
+
+it("should reject invalid address format in tokenTransfer", () => {
+	expect(() => TransactionDataEncoder.tokenTransfer("", "1000")).toThrow();
+	expect(() => TransactionDataEncoder.tokenTransfer("0x123", "1000")).toThrow();
+	expect(() => TransactionDataEncoder.tokenTransfer("0x123456789012345678901234567890123456789", "1000")).toThrow();
+});
+
+it("should reject invalid address format in multiPayment", () => {
+	expect(() => TransactionDataEncoder.multiPayment([""], ["1000"])).toThrow();
+	expect(() => TransactionDataEncoder.multiPayment(["0x123"], ["1000"])).toThrow();
+	expect(() =>
+		TransactionDataEncoder.multiPayment(["0x123456789012345678901234567890123456789"], ["1000"]),
+	).toThrow();
+});