@arkecosystem/typescript-crypto 0.0.4 → 0.0.5

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

@@ -4,6 +4,7 @@ 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 = (
@@ -11,7 +12,7 @@ it("should build a transaction", async () => {
 			.pay("0x6F0182a0cc707b055322CcF6d4CB6a5Aff1aEb22", "100000")
 			.pay("0xc3bbe9b1cee1ff85ad72b87414b0e9b7f2366763", "200000")
 			.gasPrice(fixture.data.gasPrice)
-			.gasLimit(fixture.data.gasLimit)
+			.gas(fixture.data.gas)
 			.network(fixture.data.network)
 			.sign(identityFixture.passphrase)
 	).transaction;
@@ -19,31 +20,32 @@ 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 MultipaymentBuilder.new(fixture.data).sign(identityFixture.passphrase)).transaction;
+	const transaction = (await MultipaymentBuilder.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.value).toBe(fixture.data.value);
+	expect(transaction.data.gas).toBe(fixture.data.gas);
+	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);
 	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);
@@ -54,7 +56,7 @@ it("should build a transaction with a single payment", async () => {
 		await MultipaymentBuilder.new()
 			.pay("0x6F0182a0cc707b055322CcF6d4CB6a5Aff1aEb22", "100000")
 			.gasPrice(fixtureSingle.data.gasPrice)
-			.gasLimit(fixtureSingle.data.gasLimit)
+			.gas(fixtureSingle.data.gas)
 			.network(fixtureSingle.data.network)
 			.sign(identityFixture.passphrase)
 	).transaction;
@@ -62,13 +64,13 @@ it("should build a transaction with a single payment", async () => {
 	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.gasLimit).toBe(fixtureSingle.data.gasLimit);
-	expect(transaction.data.recipientAddress).toBe(fixtureSingle.data.recipientAddress);
+	expect(transaction.data.gas).toBe(fixtureSingle.data.gas);
+	expect(transaction.data.to).toBe(fixtureSingle.data.to);
 	expect(transaction.data.value).toBe(fixtureSingle.data.value);
 	expect(transaction.data.v).toBe(fixtureSingle.data.v);
 	expect(transaction.data.r).toBe(fixtureSingle.data.r);
 	expect(transaction.data.s).toBe(fixtureSingle.data.s);
-	expect(transaction.data.id).toBe(fixtureSingle.data.id);
+	expect(transaction.data.hash).toBe(fixtureSingle.data.hash);
 
 	expect(transaction.serialize().toString("hex")).toEqual(fixtureSingle.serialized);
 	expect(transaction.verify()).toBe(true);
@@ -78,7 +80,7 @@ it("should build a transaction with an empty payment", async () => {
 	const transaction = (
 		await MultipaymentBuilder.new()
 			.gasPrice(fixtureEmpty.data.gasPrice)
-			.gasLimit(fixtureEmpty.data.gasLimit)
+			.gas(fixtureEmpty.data.gas)
 			.network(fixtureEmpty.data.network)
 			.sign(identityFixture.passphrase)
 	).transaction;
@@ -86,14 +88,120 @@ it("should build a transaction with an empty payment", async () => {
 	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.gasLimit).toBe(fixtureEmpty.data.gasLimit);
-	expect(transaction.data.recipientAddress).toBe(fixtureEmpty.data.recipientAddress);
+	expect(transaction.data.gas).toBe(fixtureEmpty.data.gas);
+	expect(transaction.data.to).toBe(fixtureEmpty.data.to);
 	expect(transaction.data.value).toBe(fixtureEmpty.data.value);
 	expect(transaction.data.v).toBe(fixtureEmpty.data.v);
 	expect(transaction.data.r).toBe(fixtureEmpty.data.r);
 	expect(transaction.data.s).toBe(fixtureEmpty.data.s);
-	expect(transaction.data.id).toBe(fixtureEmpty.data.id);
+	expect(transaction.data.hash).toBe(fixtureEmpty.data.hash);
 
 	expect(transaction.serialize().toString("hex")).toEqual(fixtureEmpty.serialized);
 	expect(transaction.verify()).toBe(true);
 });
+
+it("should handle bignumber values", async () => {
+	const transaction = (
+		await MultipaymentBuilder.new()
+			.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)
+			.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 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);
+
+	builder.transaction.data.value = undefined;
+
+	builder.pay("0x6F0182a0cc707b055322CcF6d4CB6a5Aff1aEb22", "100000");
+
+	expect(builder.transaction.data.value).toBe("100000");
+});
+
+it("should verify", async () => {
+	const transaction = await MultipaymentBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should convert to an array", async () => {
+	const transaction = await MultipaymentBuilder.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 MultipaymentBuilder.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 MultipaymentBuilder.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/TransferBuilder.test.ts

@@ -1,73 +1,172 @@
-import fixtureTransfer from "@tests/fixtures/transactions/transfer.json";
+import fixture from "@tests/fixtures/transactions/transfer.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()
-		.value(fixtureTransfer.data.value)
-		.recipientAddress(fixtureTransfer.data.recipientAddress)
-		.nonce(fixtureTransfer.data.nonce)
-		.gasPrice(fixtureTransfer.data.gasPrice)
-		.gasLimit(fixtureTransfer.data.gasLimit)
-		.network(fixtureTransfer.data.network)
-		.sign(identityFixture.passphrase)).transaction;
-
-	expect(transaction.data.gasPrice).toBe(fixtureTransfer.data.gasPrice);
-	expect(transaction.data.nonce).toBe(fixtureTransfer.data.nonce);
-	expect(transaction.data.network).toBe(fixtureTransfer.data.network);
-	expect(transaction.data.gasLimit).toBe(fixtureTransfer.data.gasLimit);
-	expect(transaction.data.recipientAddress).toBe(fixtureTransfer.data.recipientAddress);
-	expect(transaction.data.value).toBe(fixtureTransfer.data.value);
-	expect(transaction.data.v).toBe(fixtureTransfer.data.v);
-	expect(transaction.data.r).toBe(fixtureTransfer.data.r);
-	expect(transaction.data.s).toBe(fixtureTransfer.data.s);
-	expect(transaction.data.id).toBe(fixtureTransfer.data.id);
-
-	expect(transaction.serialize().toString("hex")).toEqual(fixtureTransfer.serialized);
+	const transaction = (
+		await TransferBuilder.new()
+			.value(fixture.data.value)
+			.to(fixture.data.to)
+			.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 sign a transaction", async () => {
-	const transaction = (await TransferBuilder.new(fixtureTransfer.data).sign(identityFixture.passphrase)).transaction;
-
-	expect(transaction.data.gasPrice).toBe(fixtureTransfer.data.gasPrice);
-	expect(transaction.data.nonce).toBe(fixtureTransfer.data.nonce);
-	expect(transaction.data.network).toBe(fixtureTransfer.data.network);
-	expect(transaction.data.gasLimit).toBe(fixtureTransfer.data.gasLimit);
-	expect(transaction.data.recipientAddress).toBe(fixtureTransfer.data.recipientAddress);
-	expect(transaction.data.value).toBe(fixtureTransfer.data.value);
-	expect(transaction.data.v).toBe(fixtureTransfer.data.v);
-	expect(transaction.data.r).toBe(fixtureTransfer.data.r);
-	expect(transaction.data.s).toBe(fixtureTransfer.data.s);
-	expect(transaction.data.id).toBe(fixtureTransfer.data.id);
-
-	expect(transaction.serialize().toString("hex")).toEqual(fixtureTransfer.serialized);
+	const transaction = (await TransferBuilder.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.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 large amounts", async () => {
-	const transaction = (await TransferBuilder.new()
-		.value(fixtureTransferLargeAmount.data.value)
-		.recipientAddress(fixtureTransferLargeAmount.data.recipientAddress)
-		.nonce(fixtureTransferLargeAmount.data.nonce)
-		.gasPrice(fixtureTransferLargeAmount.data.gasPrice)
-		.gasLimit(fixtureTransferLargeAmount.data.gasLimit)
-		.network(fixtureTransferLargeAmount.data.network)
-		.sign(identityFixture.passphrase)).transaction;
+	const transaction = (
+		await TransferBuilder.new()
+			.value(fixtureTransferLargeAmount.data.value)
+			.to(fixtureTransferLargeAmount.data.to)
+			.nonce(fixtureTransferLargeAmount.data.nonce)
+			.gasPrice(fixtureTransferLargeAmount.data.gasPrice)
+			.gas(fixtureTransferLargeAmount.data.gas)
+			.network(fixtureTransferLargeAmount.data.network)
+			.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.gasLimit).toBe(fixtureTransferLargeAmount.data.gasLimit);
-	expect(transaction.data.recipientAddress).toBe(fixtureTransferLargeAmount.data.recipientAddress);
+	expect(transaction.data.gas).toBe(fixtureTransferLargeAmount.data.gas);
+	expect(transaction.data.to).toBe(fixtureTransferLargeAmount.data.to);
 	expect(transaction.data.value).toBe(fixtureTransferLargeAmount.data.value);
 	expect(transaction.data.v).toBe(fixtureTransferLargeAmount.data.v);
 	expect(transaction.data.r).toBe(fixtureTransferLargeAmount.data.r);
 	expect(transaction.data.s).toBe(fixtureTransferLargeAmount.data.s);
-	expect(transaction.data.id).toBe(fixtureTransferLargeAmount.data.id);
+	expect(transaction.data.hash).toBe(fixtureTransferLargeAmount.data.hash);
 
 	expect(transaction.serialize().toString("hex")).toEqual(fixtureTransferLargeAmount.serialized);
 	expect(transaction.verify()).toBe(true);
 });
+
+it("should handle a bignumber value", async () => {
+	const transaction = (
+		await TransferBuilder.new()
+			.value(UnitConverter.parseUnits(fixture.data.value, "wei"))
+			.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)
+			.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 verify", async () => {
+	const transaction = await TransferBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should convert to an array", async () => {
+	const transaction = await TransferBuilder.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 TransferBuilder.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 TransferBuilder.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/UnvoteBuilder.test.ts

@@ -8,7 +8,7 @@ it("should build a transaction", async () => {
 		await UnvoteBuilder.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,32 +16,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 UnvoteBuilder.new(fixture.data).sign(identityFixture.passphrase)).transaction;
+	const transaction = (await UnvoteBuilder.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 UnvoteBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should convert to an array", async () => {
+	const transaction = await UnvoteBuilder.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 UnvoteBuilder.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 UnvoteBuilder.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/UsernameRegistrationBuilder.test.ts

@@ -10,7 +10,7 @@ it("should build a transaction", async () => {
 			.username("fixture")
 			.nonce(fixture.data.nonce)
 			.gasPrice(fixture.data.gasPrice)
-			.gasLimit(fixture.data.gasLimit)
+			.gas(fixture.data.gas)
 			.network(fixture.data.network)
 			.sign(identityFixture.passphrase)
 	).transaction;
@@ -18,32 +18,32 @@ 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 UsernameRegistrationBuilder.new(fixture.data).sign(identityFixture.passphrase))
+	const transaction = (await UsernameRegistrationBuilder.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);
@@ -52,3 +52,70 @@ it("should sign a transaction", async () => {
 it("should throw if username is invalid", async () => {
 	expect(() => UsernameRegistrationBuilder.new().username("invalid.username.too.long")).toThrow();
 });
+
+it("should verify", async () => {
+	const transaction = await UsernameRegistrationBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should convert to an array", async () => {
+	const transaction = await UsernameRegistrationBuilder.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 UsernameRegistrationBuilder.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 UsernameRegistrationBuilder.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,
+		}),
+	);
+});