@arkecosystem/typescript-crypto 0.0.10 → 0.0.11

package/tests/unit/transactions/Deserializer.test.ts

@@ -1,4 +1,3 @@
-import { Deserializer } from "@/transactions/Deserializer";
 import {
 	EvmCall,
 	Multipayment,
@@ -9,6 +8,8 @@ import {
 	ValidatorResignation,
 	Vote,
 } from "@/transactions/types";
+
+import { Deserializer } from "@/transactions/Deserializer";
 import { Transfer } from "@/transactions/types/Transfer";
 import fixtureTransfer from "@tests/fixtures/transactions/transfer.json";
 
@@ -40,7 +41,7 @@ it("should deserialize transfer", () => {
 		"hash",
 		"nonce",
 		"gasPrice",
-		"gas",
+		"gasLimit",
 		"value",
 		"v",
 		"r",
@@ -54,7 +55,7 @@ it("should deserialize transfer", () => {
 it("should deserialize a transfer signed with a passphrase", async () => {
 	const fixture = await getFixture("transfer");
 
-	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gas", "value", "v", "r", "s"]);
+	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gasLimit", "value", "v", "r", "s"]);
 
 	expect(transaction).toBeInstanceOf(Transfer);
 });
@@ -62,7 +63,7 @@ it("should deserialize a transfer signed with a passphrase", async () => {
 it("should deserialize a transfer signed with a passphrase with 0 value", async () => {
 	const fixture = await getFixture("transfer-0");
 
-	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gas", "value", "v", "r", "s"]);
+	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gasLimit", "value", "v", "r", "s"]);
 
 	expect(transaction).toBeInstanceOf(EvmCall);
 });
@@ -70,7 +71,7 @@ it("should deserialize a transfer signed with a passphrase with 0 value", async
 it("should deserialize a vote signed with a passphrase", async () => {
 	const fixture = await getFixture("vote");
 
-	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gas", "value", "v", "r", "s"]);
+	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gasLimit", "value", "v", "r", "s"]);
 
 	expect(transaction.data["vote"]).toEqual("0xC3bBE9B1CeE1ff85Ad72b87414B0E9B7F2366763");
 
@@ -82,7 +83,7 @@ it("should deserialize a vote signed with a passphrase", async () => {
 it("should deserialize a unvote signed with a passphrase", async () => {
 	const fixture = await getFixture("unvote");
 
-	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gas", "value", "v", "r", "s"]);
+	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gasLimit", "value", "v", "r", "s"]);
 
 	expect(transaction).toBeInstanceOf(Unvote);
 });
@@ -90,7 +91,7 @@ it("should deserialize a unvote signed with a passphrase", async () => {
 it("should deserialize a validator registration signed with a passphrase", async () => {
 	const fixture = await getFixture("validator-registration");
 
-	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gas", "value", "v", "r", "s"]);
+	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gasLimit", "value", "v", "r", "s"]);
 
 	expect(transaction).toBeInstanceOf(ValidatorRegistration);
 });
@@ -98,7 +99,7 @@ it("should deserialize a validator registration signed with a passphrase", async
 it("should deserialize a validator resignation signed with a passphrase", async () => {
 	const fixture = await getFixture("validator-resignation");
 
-	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gas", "value", "v", "r", "s"]);
+	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gasLimit", "value", "v", "r", "s"]);
 
 	expect(transaction).toBeInstanceOf(ValidatorResignation);
 });
@@ -106,7 +107,7 @@ it("should deserialize a validator resignation signed with a passphrase", async
 it("should deserialize a username registration signed with a passphrase", async () => {
 	const fixture = await getFixture("username-registration");
 
-	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gas", "value", "v", "r", "s"]);
+	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gasLimit", "value", "v", "r", "s"]);
 
 	expect(transaction).toBeInstanceOf(UsernameRegistration);
 });
@@ -114,7 +115,7 @@ it("should deserialize a username registration signed with a passphrase", async
 it("should deserialize a username resignation signed with a passphrase", async () => {
 	const fixture = await getFixture("username-resignation");
 
-	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gas", "value", "v", "r", "s"]);
+	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gasLimit", "value", "v", "r", "s"]);
 
 	expect(transaction).toBeInstanceOf(UsernameResignation);
 });
@@ -122,7 +123,7 @@ it("should deserialize a username resignation signed with a passphrase", async (
 it("should deserialize a multipayment signed with a passphrase", async () => {
 	const fixture = await getFixture("multipayment");
 
-	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gas", "value", "v", "r", "s"]);
+	const transaction = assertDeserialized(fixture, ["hash", "nonce", "gasPrice", "gasLimit", "value", "v", "r", "s"]);
 
 	expect(transaction).toBeInstanceOf(Multipayment);
 });

package/tests/unit/transactions/Serializer.test.ts

@@ -1,7 +1,6 @@
-import fixtureTransfer from "@tests/fixtures/transactions/transfer.json";
-
-import { Transfer } from "@/transactions/types/Transfer";
 import { Serializer } from "../../../src/transactions/Serializer";
+import { Transfer } from "@/transactions/types/Transfer";
+import fixtureTransfer from "@tests/fixtures/transactions/transfer.json";
 
 it("should serialize a transfer transaction", () => {
 	const transaction = new Transfer(fixtureTransfer.data);
@@ -12,8 +11,8 @@ it("should serialize a transfer transaction", () => {
 it("should serialize a transfer transaction without a signature", () => {
 	const transaction = new Transfer(fixtureTransfer.data);
 
-	// We slice the first few bytes because the serialization is different when the transaction is signed
-	expect(new Serializer(transaction).serialize(true).toString("hex").slice(4)).toEqual(
-		fixtureTransfer["serialized"].slice(6, 90),
+	// We slice the first few bytes and last bytes (dummy signature) because the serialization is different when the transaction is signed
+	expect(new Serializer(transaction).serialize(true).toString("hex").slice(4, 78)).toEqual(
+		fixtureTransfer["serialized"].slice(6, 80),
 	);
 });

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

@@ -1,8 +1,7 @@
+import { EvmCallBuilder } from "@/transactions/builders/EvmCallBuilder";
 import fixture from "@tests/fixtures/transactions/evm-sign.json";
 import identityFixture from "@tests/fixtures/identity.json";
 
-import { EvmCallBuilder } from "@/transactions/builders/EvmCallBuilder";
-
 it("should build a transaction", async () => {
 	const transaction = (
 		await EvmCallBuilder.new()
@@ -10,15 +9,13 @@ it("should build a transaction", async () => {
 			.to(fixture.data.to)
 			.nonce(fixture.data.nonce)
 			.gasPrice(fixture.data.gasPrice)
-			.gas(fixture.data.gas)
-			.network(fixture.data.network)
+			.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.network).toBe(fixture.data.network);
-	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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);
@@ -35,8 +32,7 @@ it("should sign 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.gas).toBe(fixture.data.gas);
+	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);
@@ -62,8 +58,7 @@ it("should convert to an array", async () => {
 		to: fixture.data.to,
 		value: fixture.data.value,
 		gasPrice: fixture.data.gasPrice,
-		gas: fixture.data.gas,
-		network: fixture.data.network,
+		gasLimit: fixture.data.gasLimit,
 		nonce: fixture.data.nonce,
 		v: fixture.data.v,
 		r: fixture.data.r,
@@ -79,9 +74,8 @@ it("should convert to json", async () => {
 	expect(transaction.toJson()).toEqual(
 		JSON.stringify({
 			gasPrice: fixture.data.gasPrice,
-			network: fixture.data.network,
 			hash: fixture.data.hash,
-			gas: fixture.data.gas,
+			gasLimit: fixture.data.gasLimit,
 			nonce: fixture.data.nonce,
 			senderPublicKey: fixture.data.senderPublicKey,
 			to: fixture.data.to,
@@ -100,9 +94,8 @@ it("should convert to string", async () => {
 	expect(transaction.toString()).toEqual(
 		JSON.stringify({
 			gasPrice: fixture.data.gasPrice,
-			network: fixture.data.network,
 			hash: fixture.data.hash,
-			gas: fixture.data.gas,
+			gasLimit: fixture.data.gasLimit,
 			nonce: fixture.data.nonce,
 			senderPublicKey: fixture.data.senderPublicKey,
 			to: fixture.data.to,

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

@@ -1,26 +1,23 @@
+import { MultipaymentBuilder } from "@/transactions/builders/MultipaymentBuilder";
+import { UnitConverter } from "@/utils/UnitConverter";
 import fixture from "@tests/fixtures/transactions/multipayment.json";
 import fixtureEmpty from "@tests/fixtures/transactions/multipayment-empty.json";
 import fixtureSingle from "@tests/fixtures/transactions/multipayment-single.json";
 import identityFixture from "@tests/fixtures/identity.json";
 
-import { MultipaymentBuilder } from "@/transactions/builders/MultipaymentBuilder";
-import { UnitConverter } from "@/utils/UnitConverter";
-
 it("should build a transaction", async () => {
 	const transaction = (
 		await MultipaymentBuilder.new()
 			.pay("0x6F0182a0cc707b055322CcF6d4CB6a5Aff1aEb22", "100000")
 			.pay("0xc3bbe9b1cee1ff85ad72b87414b0e9b7f2366763", "200000")
 			.gasPrice(fixture.data.gasPrice)
-			.gas(fixture.data.gas)
-			.network(fixture.data.network)
+			.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.network).toBe(fixture.data.network);
-	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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);
@@ -38,8 +35,7 @@ it("should sign 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.gas).toBe(fixture.data.gas);
+	expect(transaction.data.gasLimit).toBe(fixture.data.gasLimit);
 	expect(transaction.data.to).toBe(fixture.data.to);
 	expect(transaction.data.value).toBe(BigInt(fixture.data.value));
 	expect(transaction.data.v).toBe(fixture.data.v);
@@ -56,15 +52,13 @@ it("should build a transaction with a single payment", async () => {
 		await MultipaymentBuilder.new()
 			.pay("0x6F0182a0cc707b055322CcF6d4CB6a5Aff1aEb22", "100000")
 			.gasPrice(fixtureSingle.data.gasPrice)
-			.gas(fixtureSingle.data.gas)
-			.network(fixtureSingle.data.network)
+			.gasLimit(fixtureSingle.data.gasLimit)
 			.sign(identityFixture.passphrase)
 	).transaction;
 
 	expect(transaction.data.gasPrice).toBe(fixtureSingle.data.gasPrice);
 	expect(transaction.data.nonce).toBe(fixtureSingle.data.nonce);
-	expect(transaction.data.network).toBe(fixtureSingle.data.network);
-	expect(transaction.data.gas).toBe(fixtureSingle.data.gas);
+	expect(transaction.data.gasLimit).toBe(fixtureSingle.data.gasLimit);
 	expect(transaction.data.to).toBe(fixtureSingle.data.to);
 	expect(transaction.data.value).toBe(fixtureSingle.data.value);
 	expect(transaction.data.v).toBe(fixtureSingle.data.v);
@@ -80,15 +74,13 @@ it("should build a transaction with an empty payment", async () => {
 	const transaction = (
 		await MultipaymentBuilder.new()
 			.gasPrice(fixtureEmpty.data.gasPrice)
-			.gas(fixtureEmpty.data.gas)
-			.network(fixtureEmpty.data.network)
+			.gasLimit(fixtureEmpty.data.gasLimit)
 			.sign(identityFixture.passphrase)
 	).transaction;
 
 	expect(transaction.data.gasPrice).toBe(fixtureEmpty.data.gasPrice);
 	expect(transaction.data.nonce).toBe(fixtureEmpty.data.nonce);
-	expect(transaction.data.network).toBe(fixtureEmpty.data.network);
-	expect(transaction.data.gas).toBe(fixtureEmpty.data.gas);
+	expect(transaction.data.gasLimit).toBe(fixtureEmpty.data.gasLimit);
 	expect(transaction.data.to).toBe(fixtureEmpty.data.to);
 	expect(transaction.data.value).toBe(fixtureEmpty.data.value);
 	expect(transaction.data.v).toBe(fixtureEmpty.data.v);
@@ -106,15 +98,13 @@ it("should handle bignumber values", async () => {
 			.pay("0x6F0182a0cc707b055322CcF6d4CB6a5Aff1aEb22", UnitConverter.parseUnits("100000", "wei"))
 			.pay("0xc3bbe9b1cee1ff85ad72b87414b0e9b7f2366763", UnitConverter.parseUnits("200000", "wei"))
 			.gasPrice(UnitConverter.parseUnits(fixture.data.gasPrice, "wei"))
-			.gas(UnitConverter.parseUnits(fixture.data.gas, "wei"))
-			.network(fixture.data.network)
+			.gasLimit(UnitConverter.parseUnits(fixture.data.gasLimit, "wei"))
 			.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.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);
@@ -129,8 +119,7 @@ it("should handle bignumber values", async () => {
 it("should track value correctly on pay when initially not set", async () => {
 	const builder = await MultipaymentBuilder.new()
 		.gasPrice(fixtureSingle.data.gasPrice)
-		.gas(fixtureSingle.data.gas)
-		.network(fixtureSingle.data.network);
+		.gasLimit(fixtureSingle.data.gasLimit);
 
 	builder.transaction.data.value = undefined;
 
@@ -153,8 +142,7 @@ it("should convert to an array", async () => {
 		to: fixture.data.to,
 		value: fixture.data.value,
 		gasPrice: fixture.data.gasPrice,
-		gas: fixture.data.gas,
-		network: fixture.data.network,
+		gasLimit: fixture.data.gasLimit,
 		nonce: fixture.data.nonce,
 		v: fixture.data.v,
 		r: fixture.data.r,
@@ -170,9 +158,8 @@ it("should convert to json", async () => {
 	expect(transaction.toJson()).toEqual(
 		JSON.stringify({
 			gasPrice: fixture.data.gasPrice,
-			network: fixture.data.network,
 			hash: fixture.data.hash,
-			gas: fixture.data.gas,
+			gasLimit: fixture.data.gasLimit,
 			nonce: fixture.data.nonce,
 			senderPublicKey: fixture.data.senderPublicKey,
 			to: fixture.data.to,
@@ -191,9 +178,8 @@ it("should convert to string", async () => {
 	expect(transaction.toString()).toEqual(
 		JSON.stringify({
 			gasPrice: fixture.data.gasPrice,
-			network: fixture.data.network,
 			hash: fixture.data.hash,
-			gas: fixture.data.gas,
+			gasLimit: fixture.data.gasLimit,
 			nonce: fixture.data.nonce,
 			senderPublicKey: fixture.data.senderPublicKey,
 			to: fixture.data.to,

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

@@ -1,11 +1,10 @@
+import { TransferBuilder } from "@/transactions/builders/TransferBuilder";
+import { UnitConverter } from "@/utils/UnitConverter";
 import fixture from "@tests/fixtures/transactions/transfer.json";
 import legacySecondSignatureFixture from "@tests/fixtures/transactions/transfer-legacy-second-signature.json";
 import fixtureTransferLargeAmount from "@tests/fixtures/transactions/transfer-large-amount.json";
 import identityFixture from "@tests/fixtures/identity.json";
 
-import { TransferBuilder } from "@/transactions/builders/TransferBuilder";
-import { UnitConverter } from "@/utils/UnitConverter";
-
 it("should build a transaction", async () => {
 	const transaction = (
 		await TransferBuilder.new()
@@ -13,15 +12,13 @@ it("should build a transaction", async () => {
 			.to(fixture.data.to)
 			.nonce(fixture.data.nonce)
 			.gasPrice(fixture.data.gasPrice)
-			.gas(fixture.data.gas)
-			.network(fixture.data.network)
+			.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.network).toBe(fixture.data.network);
-	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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);
@@ -38,8 +35,7 @@ it("should sign 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.gas).toBe(fixture.data.gas);
+	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);
@@ -58,22 +54,19 @@ it("should build a transaction using legacy second signature", async () => {
 			.to(legacySecondSignatureFixture.data.to)
 			.nonce(legacySecondSignatureFixture.data.nonce)
 			.gasPrice(legacySecondSignatureFixture.data.gasPrice)
-			.gas(legacySecondSignatureFixture.data.gas)
-			.network(legacySecondSignatureFixture.data.network)
-			.legacySecondSign(identityFixture.passphrase, identityFixture.passphrase)
+			.gasLimit(legacySecondSignatureFixture.data.gasLimit)
+			.legacySecondSign(identityFixture.passphrase, identityFixture.secondPassphrase)
 	).transaction;
 
 	expect(transaction.data.gasPrice).toBe(legacySecondSignatureFixture.data.gasPrice);
+	expect(transaction.data.gasLimit).toBe(legacySecondSignatureFixture.data.gasLimit);
 	expect(transaction.data.nonce).toBe(legacySecondSignatureFixture.data.nonce);
-	expect(transaction.data.network).toBe(legacySecondSignatureFixture.data.network);
-	expect(transaction.data.gas).toBe(legacySecondSignatureFixture.data.gas);
 	expect(transaction.data.to).toBe(legacySecondSignatureFixture.data.to);
 	expect(transaction.data.value).toBe(legacySecondSignatureFixture.data.value);
 	expect(transaction.data.v).toBe(legacySecondSignatureFixture.data.v);
 	expect(transaction.data.r).toBe(legacySecondSignatureFixture.data.r);
 	expect(transaction.data.s).toBe(legacySecondSignatureFixture.data.s);
 	expect(transaction.data.hash).toBe(legacySecondSignatureFixture.data.hash);
-	expect(transaction.data.hash).toBe(legacySecondSignatureFixture.data.hash);
 	expect(transaction.data.legacySecondSignature).toBe(legacySecondSignatureFixture.data.legacySecondSignature);
 
 	expect(transaction.serialize().toString("hex")).toEqual(legacySecondSignatureFixture.serialized);
@@ -87,15 +80,13 @@ it("should handle large amounts", async () => {
 			.to(fixtureTransferLargeAmount.data.to)
 			.nonce(fixtureTransferLargeAmount.data.nonce)
 			.gasPrice(fixtureTransferLargeAmount.data.gasPrice)
-			.gas(fixtureTransferLargeAmount.data.gas)
-			.network(fixtureTransferLargeAmount.data.network)
+			.gasLimit(fixtureTransferLargeAmount.data.gasLimit)
 			.sign(identityFixture.passphrase)
 	).transaction;
 
 	expect(transaction.data.gasPrice).toBe(fixtureTransferLargeAmount.data.gasPrice);
 	expect(transaction.data.nonce).toBe(fixtureTransferLargeAmount.data.nonce);
-	expect(transaction.data.network).toBe(fixtureTransferLargeAmount.data.network);
-	expect(transaction.data.gas).toBe(fixtureTransferLargeAmount.data.gas);
+	expect(transaction.data.gasLimit).toBe(fixtureTransferLargeAmount.data.gasLimit);
 	expect(transaction.data.to).toBe(fixtureTransferLargeAmount.data.to);
 	expect(transaction.data.value).toBe(fixtureTransferLargeAmount.data.value);
 	expect(transaction.data.v).toBe(fixtureTransferLargeAmount.data.v);
@@ -114,15 +105,13 @@ it("should handle a bignumber value", async () => {
 			.to(fixture.data.to)
 			.nonce(fixture.data.nonce)
 			.gasPrice(UnitConverter.parseUnits(fixture.data.gasPrice, "wei"))
-			.gas(UnitConverter.parseUnits(fixture.data.gas, "wei"))
-			.network(fixture.data.network)
+			.gasLimit(UnitConverter.parseUnits(fixture.data.gasLimit, "wei"))
 			.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.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);
@@ -148,8 +137,7 @@ it("should convert to an array", async () => {
 		to: fixture.data.to,
 		value: fixture.data.value,
 		gasPrice: fixture.data.gasPrice,
-		gas: fixture.data.gas,
-		network: fixture.data.network,
+		gasLimit: fixture.data.gasLimit,
 		nonce: fixture.data.nonce,
 		v: fixture.data.v,
 		r: fixture.data.r,
@@ -165,9 +153,8 @@ it("should convert to json", async () => {
 	expect(transaction.toJson()).toEqual(
 		JSON.stringify({
 			gasPrice: fixture.data.gasPrice,
-			network: fixture.data.network,
 			hash: fixture.data.hash,
-			gas: fixture.data.gas,
+			gasLimit: fixture.data.gasLimit,
 			nonce: fixture.data.nonce,
 			senderPublicKey: fixture.data.senderPublicKey,
 			to: fixture.data.to,
@@ -186,9 +173,8 @@ it("should convert to string", async () => {
 	expect(transaction.toString()).toEqual(
 		JSON.stringify({
 			gasPrice: fixture.data.gasPrice,
-			network: fixture.data.network,
 			hash: fixture.data.hash,
-			gas: fixture.data.gas,
+			gasLimit: fixture.data.gasLimit,
 			nonce: fixture.data.nonce,
 			senderPublicKey: fixture.data.senderPublicKey,
 			to: fixture.data.to,

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

@@ -1,22 +1,19 @@
+import { UnvoteBuilder } from "@/transactions/builders/UnvoteBuilder";
 import fixture from "@tests/fixtures/transactions/unvote.json";
 import identityFixture from "@tests/fixtures/identity.json";
 
-import { UnvoteBuilder } from "@/transactions/builders/UnvoteBuilder";
-
 it("should build a transaction", async () => {
 	const transaction = (
 		await UnvoteBuilder.new()
 			.nonce(fixture.data.nonce)
 			.gasPrice(fixture.data.gasPrice)
-			.gas(fixture.data.gas)
-			.network(fixture.data.network)
+			.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.network).toBe(fixture.data.network);
-	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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);
@@ -33,8 +30,7 @@ it("should sign 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.gas).toBe(fixture.data.gas);
+	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);
@@ -60,8 +56,7 @@ it("should convert to an array", async () => {
 		to: fixture.data.to,
 		value: fixture.data.value,
 		gasPrice: fixture.data.gasPrice,
-		gas: fixture.data.gas,
-		network: fixture.data.network,
+		gasLimit: fixture.data.gasLimit,
 		nonce: fixture.data.nonce,
 		v: fixture.data.v,
 		r: fixture.data.r,
@@ -77,9 +72,8 @@ it("should convert to json", async () => {
 	expect(transaction.toJson()).toEqual(
 		JSON.stringify({
 			gasPrice: fixture.data.gasPrice,
-			network: fixture.data.network,
 			hash: fixture.data.hash,
-			gas: fixture.data.gas,
+			gasLimit: fixture.data.gasLimit,
 			nonce: fixture.data.nonce,
 			senderPublicKey: fixture.data.senderPublicKey,
 			to: fixture.data.to,
@@ -98,9 +92,8 @@ it("should convert to string", async () => {
 	expect(transaction.toString()).toEqual(
 		JSON.stringify({
 			gasPrice: fixture.data.gasPrice,
-			network: fixture.data.network,
 			hash: fixture.data.hash,
-			gas: fixture.data.gas,
+			gasLimit: fixture.data.gasLimit,
 			nonce: fixture.data.nonce,
 			senderPublicKey: fixture.data.senderPublicKey,
 			to: fixture.data.to,

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

@@ -1,8 +1,7 @@
-import fixture from "@tests/fixtures/transactions/username-registration.json";
-import identityFixture from "@tests/fixtures/identity.json";
-
 import { InvalidUsernameException } from "@/exceptions/InvalidUsernameException";
 import { UsernameRegistrationBuilder } from "@/transactions/builders/UsernameRegistrationBuilder";
+import fixture from "@tests/fixtures/transactions/username-registration.json";
+import identityFixture from "@tests/fixtures/identity.json";
 
 it("should build a transaction", async () => {
 	const transaction = (
@@ -10,15 +9,13 @@ it("should build a transaction", async () => {
 			.username("fixture")
 			.nonce(fixture.data.nonce)
 			.gasPrice(fixture.data.gasPrice)
-			.gas(fixture.data.gas)
-			.network(fixture.data.network)
+			.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.network).toBe(fixture.data.network);
-	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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);
@@ -36,8 +33,7 @@ it("should sign 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.gas).toBe(fixture.data.gas);
+	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);
@@ -67,8 +63,7 @@ it("should convert to an array", async () => {
 		to: fixture.data.to,
 		value: fixture.data.value,
 		gasPrice: fixture.data.gasPrice,
-		gas: fixture.data.gas,
-		network: fixture.data.network,
+		gasLimit: fixture.data.gasLimit,
 		nonce: fixture.data.nonce,
 		v: fixture.data.v,
 		r: fixture.data.r,
@@ -84,9 +79,8 @@ it("should convert to json", async () => {
 	expect(transaction.toJson()).toEqual(
 		JSON.stringify({
 			gasPrice: fixture.data.gasPrice,
-			network: fixture.data.network,
 			hash: fixture.data.hash,
-			gas: fixture.data.gas,
+			gasLimit: fixture.data.gasLimit,
 			nonce: fixture.data.nonce,
 			senderPublicKey: fixture.data.senderPublicKey,
 			to: fixture.data.to,
@@ -105,9 +99,8 @@ it("should convert to string", async () => {
 	expect(transaction.toString()).toEqual(
 		JSON.stringify({
 			gasPrice: fixture.data.gasPrice,
-			network: fixture.data.network,
 			hash: fixture.data.hash,
-			gas: fixture.data.gas,
+			gasLimit: fixture.data.gasLimit,
 			nonce: fixture.data.nonce,
 			senderPublicKey: fixture.data.senderPublicKey,
 			to: fixture.data.to,

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

@@ -1,22 +1,19 @@
+import { UsernameResignationBuilder } from "@/transactions/builders/UsernameResignationBuilder";
 import fixture from "@tests/fixtures/transactions/username-resignation.json";
 import identityFixture from "@tests/fixtures/identity.json";
 
-import { UsernameResignationBuilder } from "@/transactions/builders/UsernameResignationBuilder";
-
 it("should build a transaction", async () => {
 	const transaction = (
 		await UsernameResignationBuilder.new()
 			.nonce(fixture.data.nonce)
 			.gasPrice(fixture.data.gasPrice)
-			.gas(fixture.data.gas)
-			.network(fixture.data.network)
+			.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.network).toBe(fixture.data.network);
-	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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);
@@ -34,8 +31,7 @@ it("should sign 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.gas).toBe(fixture.data.gas);
+	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);
@@ -61,8 +57,7 @@ it("should convert to an array", async () => {
 		to: fixture.data.to,
 		value: fixture.data.value,
 		gasPrice: fixture.data.gasPrice,
-		gas: fixture.data.gas,
-		network: fixture.data.network,
+		gasLimit: fixture.data.gasLimit,
 		nonce: fixture.data.nonce,
 		v: fixture.data.v,
 		r: fixture.data.r,
@@ -78,9 +73,8 @@ it("should convert to json", async () => {
 	expect(transaction.toJson()).toEqual(
 		JSON.stringify({
 			gasPrice: fixture.data.gasPrice,
-			network: fixture.data.network,
 			hash: fixture.data.hash,
-			gas: fixture.data.gas,
+			gasLimit: fixture.data.gasLimit,
 			nonce: fixture.data.nonce,
 			senderPublicKey: fixture.data.senderPublicKey,
 			to: fixture.data.to,
@@ -99,9 +93,8 @@ it("should convert to string", async () => {
 	expect(transaction.toString()).toEqual(
 		JSON.stringify({
 			gasPrice: fixture.data.gasPrice,
-			network: fixture.data.network,
 			hash: fixture.data.hash,
-			gas: fixture.data.gas,
+			gasLimit: fixture.data.gasLimit,
 			nonce: fixture.data.nonce,
 			senderPublicKey: fixture.data.senderPublicKey,
 			to: fixture.data.to,