@arkecosystem/typescript-crypto 0.0.3 → 0.0.5

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

@@ -8,7 +8,7 @@ it("should build a transaction", async () => {
 		await UsernameResignationBuilder.new()
 			.nonce(fixture.data.nonce)
 			.gasPrice(fixture.data.gasPrice)
-			.gasLimit(fixture.data.gasLimit)
+			.gas(fixture.data.gas)
 			.network(fixture.data.network)
 			.sign(identityFixture.passphrase)
 	).transaction;
@@ -16,33 +16,100 @@ it("should build a transaction", async () => {
 	expect(transaction.data.gasPrice).toBe(fixture.data.gasPrice);
 	expect(transaction.data.nonce).toBe(fixture.data.nonce);
 	expect(transaction.data.network).toBe(fixture.data.network);
-	expect(transaction.data.gasLimit).toBe(fixture.data.gasLimit);
-	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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.id).toBe(fixture.data.id);
+	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 transaction", async () => {
-	const transaction = (await UsernameResignationBuilder.new(fixture.data).sign(identityFixture.passphrase))
+	const transaction = (await UsernameResignationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase))
 		.transaction;
 
 	expect(transaction.data.gasPrice).toBe(fixture.data.gasPrice);
 	expect(transaction.data.nonce).toBe(fixture.data.nonce);
 	expect(transaction.data.network).toBe(fixture.data.network);
-	expect(transaction.data.gasLimit).toBe(fixture.data.gasLimit);
-	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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.id).toBe(fixture.data.id);
+	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 UsernameResignationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should convert to an array", async () => {
+	const transaction = await UsernameResignationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toObject()).toEqual({
+		data: fixture.data.data,
+		to: fixture.data.to,
+		value: fixture.data.value,
+		gasPrice: fixture.data.gasPrice,
+		gas: fixture.data.gas,
+		network: fixture.data.network,
+		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 UsernameResignationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toJson()).toEqual(
+		JSON.stringify({
+			gasPrice: fixture.data.gasPrice,
+			network: fixture.data.network,
+			hash: fixture.data.hash,
+			gas: fixture.data.gas,
+			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 UsernameResignationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toString()).toEqual(
+		JSON.stringify({
+			gasPrice: fixture.data.gasPrice,
+			network: fixture.data.network,
+			hash: fixture.data.hash,
+			gas: fixture.data.gas,
+			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/transactions/builders/ValidatorRegistrationBuilder.test.ts

@@ -4,6 +4,34 @@ import identityFixture from "@tests/fixtures/identity.json";
 import { ValidatorRegistrationBuilder } from "@/transactions/builders/ValidatorRegistrationBuilder";
 
 it("should build a transaction", async () => {
+	const transaction = (
+		await ValidatorRegistrationBuilder.new()
+			.validatorPublicKey(
+				"30954f46d6097a1d314e900e66e11e0dad0a57cd03e04ec99f0dedd1c765dcb11e6d7fa02e22cf40f9ee23d9cc1c0624",
+			)
+			.nonce(fixture.data.nonce)
+			.gasPrice(fixture.data.gasPrice)
+			.gas(fixture.data.gas)
+			.network(fixture.data.network)
+			.sign(identityFixture.passphrase)
+	).transaction;
+
+	expect(transaction.data.gasPrice).toBe(fixture.data.gasPrice);
+	expect(transaction.data.nonce).toBe(fixture.data.nonce);
+	expect(transaction.data.network).toBe(fixture.data.network);
+	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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 handle validator public key with leading 0x", async () => {
 	const transaction = (
 		await ValidatorRegistrationBuilder.new()
 			.validatorPublicKey(
@@ -11,7 +39,7 @@ it("should build a transaction", async () => {
 			)
 			.nonce(fixture.data.nonce)
 			.gasPrice(fixture.data.gasPrice)
-			.gasLimit(fixture.data.gasLimit)
+			.gas(fixture.data.gas)
 			.network(fixture.data.network)
 			.sign(identityFixture.passphrase)
 	).transaction;
@@ -19,33 +47,100 @@ it("should build a transaction", async () => {
 	expect(transaction.data.gasPrice).toBe(fixture.data.gasPrice);
 	expect(transaction.data.nonce).toBe(fixture.data.nonce);
 	expect(transaction.data.network).toBe(fixture.data.network);
-	expect(transaction.data.gasLimit).toBe(fixture.data.gasLimit);
-	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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.id).toBe(fixture.data.id);
+	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 transaction", async () => {
-	const transaction = (await ValidatorRegistrationBuilder.new(fixture.data).sign(identityFixture.passphrase))
+	const transaction = (await ValidatorRegistrationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase))
 		.transaction;
 
 	expect(transaction.data.gasPrice).toBe(fixture.data.gasPrice);
 	expect(transaction.data.nonce).toBe(fixture.data.nonce);
 	expect(transaction.data.network).toBe(fixture.data.network);
-	expect(transaction.data.gasLimit).toBe(fixture.data.gasLimit);
-	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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.id).toBe(fixture.data.id);
+	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 ValidatorRegistrationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should convert to an array", async () => {
+	const transaction = await ValidatorRegistrationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toObject()).toEqual({
+		data: fixture.data.data,
+		to: fixture.data.to,
+		value: fixture.data.value,
+		gasPrice: fixture.data.gasPrice,
+		gas: fixture.data.gas,
+		network: fixture.data.network,
+		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 ValidatorRegistrationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toJson()).toEqual(
+		JSON.stringify({
+			gasPrice: fixture.data.gasPrice,
+			network: fixture.data.network,
+			hash: fixture.data.hash,
+			gas: fixture.data.gas,
+			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 ValidatorRegistrationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toString()).toEqual(
+		JSON.stringify({
+			gasPrice: fixture.data.gasPrice,
+			network: fixture.data.network,
+			hash: fixture.data.hash,
+			gas: fixture.data.gas,
+			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/transactions/builders/ValidatorResignationBuilder.test.ts

@@ -8,7 +8,7 @@ it("should build a transaction", async () => {
 		await ValidatorResignationBuilder.new()
 			.nonce(fixture.data.nonce)
 			.gasPrice(fixture.data.gasPrice)
-			.gasLimit(fixture.data.gasLimit)
+			.gas(fixture.data.gas)
 			.network(fixture.data.network)
 			.sign(identityFixture.passphrase)
 	).transaction;
@@ -16,33 +16,100 @@ it("should build a transaction", async () => {
 	expect(transaction.data.gasPrice).toBe(fixture.data.gasPrice);
 	expect(transaction.data.nonce).toBe(fixture.data.nonce);
 	expect(transaction.data.network).toBe(fixture.data.network);
-	expect(transaction.data.gasLimit).toBe(fixture.data.gasLimit);
-	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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.id).toBe(fixture.data.id);
+	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 transaction", async () => {
-	const transaction = (await ValidatorResignationBuilder.new(fixture.data).sign(identityFixture.passphrase))
+	const transaction = (await ValidatorResignationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase))
 		.transaction;
 
 	expect(transaction.data.gasPrice).toBe(fixture.data.gasPrice);
 	expect(transaction.data.nonce).toBe(fixture.data.nonce);
 	expect(transaction.data.network).toBe(fixture.data.network);
-	expect(transaction.data.gasLimit).toBe(fixture.data.gasLimit);
-	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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.id).toBe(fixture.data.id);
+	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 ValidatorResignationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should convert to an array", async () => {
+	const transaction = await ValidatorResignationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toObject()).toEqual({
+		data: fixture.data.data,
+		to: fixture.data.to,
+		value: fixture.data.value,
+		gasPrice: fixture.data.gasPrice,
+		gas: fixture.data.gas,
+		network: fixture.data.network,
+		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 ValidatorResignationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toJson()).toEqual(
+		JSON.stringify({
+			gasPrice: fixture.data.gasPrice,
+			network: fixture.data.network,
+			hash: fixture.data.hash,
+			gas: fixture.data.gas,
+			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 ValidatorResignationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toString()).toEqual(
+		JSON.stringify({
+			gasPrice: fixture.data.gasPrice,
+			network: fixture.data.network,
+			hash: fixture.data.hash,
+			gas: fixture.data.gas,
+			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/transactions/builders/VoteBuilder.test.ts

@@ -9,7 +9,7 @@ it("should build a transaction", async () => {
 			.vote("0xc3bbe9b1cee1ff85ad72b87414b0e9b7f2366763")
 			.nonce(fixture.data.nonce)
 			.gasPrice(fixture.data.gasPrice)
-			.gasLimit(fixture.data.gasLimit)
+			.gas(fixture.data.gas)
 			.network(fixture.data.network)
 			.sign(identityFixture.passphrase)
 	).transaction;
@@ -17,32 +17,99 @@ it("should build a transaction", async () => {
 	expect(transaction.data.gasPrice).toBe(fixture.data.gasPrice);
 	expect(transaction.data.nonce).toBe(fixture.data.nonce);
 	expect(transaction.data.network).toBe(fixture.data.network);
-	expect(transaction.data.gasLimit).toBe(fixture.data.gasLimit);
-	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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.id).toBe(fixture.data.id);
+	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 transaction", async () => {
-	const transaction = (await VoteBuilder.new(fixture.data).sign(identityFixture.passphrase)).transaction;
+	const transaction = (await VoteBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase)).transaction;
 
 	expect(transaction.data.gasPrice).toBe(fixture.data.gasPrice);
 	expect(transaction.data.nonce).toBe(fixture.data.nonce);
 	expect(transaction.data.network).toBe(fixture.data.network);
-	expect(transaction.data.gasLimit).toBe(fixture.data.gasLimit);
-	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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.id).toBe(fixture.data.id);
+	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 VoteBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should convert to an array", async () => {
+	const transaction = await VoteBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toObject()).toEqual({
+		data: fixture.data.data,
+		to: fixture.data.to,
+		value: fixture.data.value,
+		gasPrice: fixture.data.gasPrice,
+		gas: fixture.data.gas,
+		network: fixture.data.network,
+		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 VoteBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toJson()).toEqual(
+		JSON.stringify({
+			gasPrice: fixture.data.gasPrice,
+			network: fixture.data.network,
+			hash: fixture.data.hash,
+			gas: fixture.data.gas,
+			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 VoteBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toString()).toEqual(
+		JSON.stringify({
+			gasPrice: fixture.data.gasPrice,
+			network: fixture.data.network,
+			hash: fixture.data.hash,
+			gas: fixture.data.gas,
+			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/transactions/types/AbstractTransaction.test.ts

@@ -1,26 +1,11 @@
 import fixture from "@tests/fixtures/transactions/transfer.json";
 import fixtureGlobal from "@tests/fixtures/global.json";
-import fixtureVote from "@tests/fixtures/transactions/vote.json";
 
 import { AbstractTransaction } from "@/transactions/types/AbstractTransaction";
 import { PrivateKey } from "@/identities/PrivateKey";
 import { TransactionData } from "@/types";
 import { Transfer } from "@/transactions/types/Transfer";
 
-class DecoderTransaction extends AbstractTransaction {
-	constructor(data: TransactionData) {
-		super(data);
-
-		this.decodePayload(data);
-
-		this.refreshPayloadData();
-	}
-
-	getPayload(): string {
-		return "7061796C6F6164";
-	}
-}
-
 class Transaction extends AbstractTransaction {
 	getPayload(): string {
 		return "7061796C6F6164";
@@ -55,12 +40,6 @@ it("should refresh the payload", () => {
 	expect(transaction.data.data).toEqual("updated-payload");
 });
 
-it("should get the id", () => {
-	const transaction = new Transfer(fixture.data);
-
-	expect(transaction.getId()).toEqual(fixture.data.id);
-});
-
 it("should sign a transaction", () => {
 	const privateKey = PrivateKey.fromPassphrase(fixtureGlobal.passphrase);
 	const transaction = new Transfer(fixture.data);
@@ -78,7 +57,7 @@ it("should recover the sender", () => {
 	transaction.recoverSender();
 
 	expect(transaction.data.senderPublicKey).toEqual(fixture.data.senderPublicKey);
-	expect(transaction.data.senderAddress).toEqual(fixture.data.senderAddress);
+	expect(transaction.data.from).toEqual(fixture.data.from);
 });
 
 it("should verify the transaction", () => {
@@ -87,6 +66,28 @@ it("should verify the transaction", () => {
 	expect(transaction.verify()).toBe(true);
 });
 
+it("should not verify if there is no sender public key", () => {
+	const transaction = new Transfer({
+		...fixture.data,
+
+		senderPublicKey: undefined,
+	});
+
+	expect(transaction.verify()).toBe(false);
+});
+
+it("should throw an error if no signature", () => {
+	const transaction = new Transfer({
+		...fixture.data,
+
+		v: undefined,
+		r: undefined,
+		s: undefined,
+	});
+
+	expect(() => transaction.verify()).toThrow("Transaction signature is missing");
+});
+
 it("should convert the transaction to json", () => {
 	const transaction = new Transaction(fixture.data);
 
@@ -94,11 +95,11 @@ it("should convert the transaction to json", () => {
 		JSON.stringify({
 			gasPrice: fixture.data["gasPrice"],
 			network: fixture.data["network"],
-			id: fixture.data["id"],
-			gasLimit: fixture.data["gasLimit"],
+			hash: fixture.data["hash"],
+			gas: fixture.data["gas"],
 			nonce: fixture.data["nonce"],
 			senderPublicKey: fixture.data["senderPublicKey"],
-			recipientAddress: fixture.data["recipientAddress"],
+			to: fixture.data["to"],
 			value: fixture.data["value"],
 			data: "7061796C6F6164",
 			r: fixture.data["r"],
@@ -111,7 +112,7 @@ it("should convert the transaction to json", () => {
 it("should generate a hash for the transaction with signature", () => {
 	const transaction = new Transfer(fixture.data);
 
-	expect(transaction.hash()).toEqual(fixture.data.id);
+	expect(transaction.hash()).toEqual(fixture.data.hash);
 });
 
 it("should generate a hash for the transaction without signature", () => {
@@ -139,7 +140,3 @@ it("should serialize the transaction without signature", () => {
 	// We don't store serialized without the signature in the fixtures so we do a partial check
 	expect(fixture.serialized).toContain(serialized.substring(4));
 });
-
-it("should decode the payload", () => {
-	expect(() => new DecoderTransaction(fixtureVote.data)).toThrow("Method not implemented");
-});

package/tests/unit/transactions/types/EvmCall.test.ts

@@ -0,0 +1,22 @@
+import { EvmCall } from "@/transactions/types/EvmCall";
+import { AbstractTransaction } from "@/transactions/types/AbstractTransaction";
+import fixture from "@tests/fixtures/transactions/evm-sign.json";
+
+it("should create a new instance", () => {
+	const transaction = new EvmCall(fixture.data);
+
+	expect(transaction).toBeInstanceOf(EvmCall);
+	expect(transaction).toBeInstanceOf(AbstractTransaction);
+
+	expect(transaction.data.data).toEqual(
+		"a9059cbb00000000000000000000000027fa7caffaae77ddb9ab232fdbda56d5e5af23930000000000000000000000000000000000000000000000000000000000000064",
+	);
+});
+
+it("should get payload", () => {
+	const transaction = new EvmCall(fixture.data);
+
+	expect(transaction.getPayload()).toEqual(
+		"a9059cbb00000000000000000000000027fa7caffaae77ddb9ab232fdbda56d5e5af23930000000000000000000000000000000000000000000000000000000000000064",
+	);
+});

package/tests/unit/transactions/types/Multipayment.test.ts

@@ -0,0 +1,38 @@
+import { Multipayment } from "@/transactions/types/Multipayment";
+import { AbstractTransaction } from "@/transactions/types/AbstractTransaction";
+import fixture from "@tests/fixtures/transactions/multipayment.json";
+
+it("should create a new instance", () => {
+	const transaction = new Multipayment(fixture.data);
+
+	expect(transaction).toBeInstanceOf(Multipayment);
+	expect(transaction).toBeInstanceOf(AbstractTransaction);
+
+	expect(transaction.data.data).toEqual(
+		"084ce708000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000020000000000000000000000006f0182a0cc707b055322ccf6d4cb6a5aff1aeb22000000000000000000000000c3bbe9b1cee1ff85ad72b87414b0e9b7f2366763000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000186a00000000000000000000000000000000000000000000000000000000000030d40",
+	);
+});
+
+it("should get payload", () => {
+	const transaction = new Multipayment(fixture.data);
+
+	expect(transaction.getPayload()).toEqual(
+		"084ce708000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000020000000000000000000000006f0182a0cc707b055322ccf6d4cb6a5aff1aeb22000000000000000000000000c3bbe9b1cee1ff85ad72b87414b0e9b7f2366763000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000186a00000000000000000000000000000000000000000000000000000000000030d40",
+	);
+});
+
+it("should handle no payload", () => {
+	const transaction = new Multipayment(fixture.data);
+
+	transaction.data.pay = [];
+
+	expect(transaction.getPayload()).toEqual("");
+
+	transaction.data.pay = null;
+
+	expect(transaction.getPayload()).toEqual("");
+
+	transaction.data.pay = undefined;
+
+	expect(transaction.getPayload()).toEqual("");
+});