@arkecosystem/typescript-crypto 0.0.1

package/tests/unit/identities/PrivateKey.test.ts

@@ -0,0 +1,36 @@
+import fixtureIdentity from "@tests/fixtures/identity.json";
+import fixtureSignCompact from "@tests/fixtures/sign-compact.json";
+import { PrivateKey } from "@/identities/PrivateKey";
+
+it('should parse the private key from passphrase', () => {
+	const actual = PrivateKey.fromPassphrase(fixtureIdentity.passphrase);
+
+	expect(actual.privateKey).toEqual(fixtureIdentity.data.privateKey);
+});
+
+it('should parse the private key from hex', () => {
+	const actual = PrivateKey.fromHex(fixtureIdentity.data.privateKey);
+
+	expect(actual.privateKey).toEqual(fixtureIdentity.data.privateKey);
+});
+
+it('should parse the private key from wif', () => {
+	const actual = PrivateKey.fromWif(fixtureIdentity.data.wif);
+
+	expect(actual.privateKey).toEqual(fixtureIdentity.data.privateKey);
+});
+
+it('should parse the private key from wif', () => {
+	const actual = PrivateKey.fromWif(fixtureIdentity.data.wif);
+
+	expect(actual.privateKey).toEqual(fixtureIdentity.data.privateKey);
+});
+
+it('should sign compact correctly', async () => {
+	const privateKey = PrivateKey.fromPassphrase(fixtureSignCompact.passphrase);
+	const signature = await privateKey.sign(fixtureSignCompact.data.message);
+
+	expect(signature.v).toBe(fixtureSignCompact.data.v);
+	expect(signature.r).toBe(fixtureSignCompact.data.r);
+	expect(signature.s).toBe(fixtureSignCompact.data.s);
+});

package/tests/unit/identities/PublicKey.test.ts

@@ -0,0 +1,39 @@
+import fixture from "@tests/fixtures/identity.json";
+import fixtureTransaction from "@tests/fixtures/transactions/transfer.json";
+
+import { PublicKey } from "@/identities/PublicKey";
+import { TransactionUtils } from "@/utils/TransactionUtils";
+
+it('should get the address from passphrase', () => {
+	const actual = PublicKey.fromPassphrase(fixture.passphrase);
+
+	expect(actual.publicKey).toEqual(fixture.data.publicKey);
+});
+
+it('should get the address from hex', () => {
+	const actual = PublicKey.fromHex(fixture.data.publicKey);
+
+	expect(actual.publicKey).toEqual(fixture.data.publicKey);
+});
+
+it('should recover a public key', () => {
+	const hash = TransactionUtils.toHash(fixtureTransaction.data, true);
+	const v = fixtureTransaction.data.v - 27;
+	const r = BigInt(`0x${fixtureTransaction.data.r}`);
+	const s = BigInt(`0x${fixtureTransaction.data.s}`);
+
+	const actual = PublicKey.recover(Buffer.from(hash, 'hex'), r, s, v);
+
+	expect(actual.publicKey).toEqual(fixture.data.publicKey);
+});
+
+it('should throw error with invalid recovery id', () => {
+	const hash = TransactionUtils.toHash(fixtureTransaction.data, true);
+	const r = BigInt(`0x${fixtureTransaction.data.r}`);
+	const s = BigInt(`0x${fixtureTransaction.data.s}`);
+
+	expect(() => PublicKey.recover(Buffer.from(hash, 'hex'), r, s, 4)).toThrow("recovery id invalid");
+	expect(() => PublicKey.recover(Buffer.from(hash, 'hex'), r, s, 5)).toThrow("recovery id invalid");
+	expect(() => PublicKey.recover(Buffer.from(hash, 'hex'), r, s, 26)).toThrow("recovery id invalid");
+	expect(() => PublicKey.recover(Buffer.from(hash, 'hex'), r, s, 27)).toThrow("recovery id invalid");
+});

package/tests/unit/identities/WIF.test.ts

@@ -0,0 +1,8 @@
+import fixture from "@tests/fixtures/identity.json";
+import { WIF } from "@/identities/WIF";
+
+it('it should get the wif from passphrase', () => {
+	const actual = WIF.fromPassphrase(fixture.passphrase);
+
+	expect(actual).toEqual(fixture.data.wif);
+});

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

@@ -0,0 +1,138 @@
+import { Deserializer } from "@/transactions/Deserializer";
+import { EvmCall, Multipayment, Unvote, UsernameRegistration, UsernameResignation, ValidatorRegistration, ValidatorResignation, Vote } from "@/transactions/types";
+import { Transfer } from "@/transactions/types/Transfer";
+import fixtureTransfer from "@tests/fixtures/transactions/transfer.json";
+
+function assertDeserialized(fixture: any, keys: string[]) {
+    const deserializer = Deserializer.new(fixture['serialized'])
+    const transaction = deserializer.deserialize()
+    for (const key in keys) {
+		try {
+			expect(transaction.data[key]).toEqual(fixture['data'][key])
+		} catch (e) {
+			console.log(`Mismatch in ${key}`)
+
+			throw e
+		}
+	}
+
+    expect(transaction.serialize().toString('binary')).toEqual(fixture['serialized']);
+    expect(transaction.verify()).toBe(true);
+
+    return transaction
+}
+
+const getFixture = async (name: string) => {
+	return (await import(`@tests/fixtures/transactions/${name}.json`)).default;
+};
+
+it('should deserialize transfer', () => {
+    const transaction = assertDeserialized(fixtureTransfer, ['id', 'nonce', 'gasPrice', 'gasLimit', 'value', 'v', 'r', 's']);
+
+    expect(transaction).toBeInstanceOf(Transfer);
+    expect(transaction.data['value']).toEqual('100000000')
+});
+
+it('should deserialize a transfer signed with a passphrase', async () => {
+	const fixture = await getFixture('transfer');
+
+	const transaction = assertDeserialized(fixture, ['id', 'nonce', 'gasPrice', 'gasLimit', 'value', 'v', 'r', 's']);
+
+	expect(transaction).toBeInstanceOf(Transfer);
+});
+
+it('should deserialize a transfer signed with a passphrase with 0 value', async () => {
+	const fixture = await getFixture('transfer-0');
+
+	const transaction = assertDeserialized(fixture, ['id', 'nonce', 'gasPrice', 'gasLimit', 'value', 'v', 'r', 's']);
+
+	expect(transaction).toBeInstanceOf(EvmCall);
+});
+
+it('should deserialize a vote signed with a passphrase', async () => {
+	const fixture = await getFixture('vote');
+
+	const transaction = assertDeserialized(fixture, ['id', 'nonce', 'gasPrice', 'gasLimit', 'value', 'v', 'r', 's']);
+
+	expect(transaction.data['vote']).toEqual('0xC3bBE9B1CeE1ff85Ad72b87414B0E9B7F2366763');
+
+	expect(transaction.data['id']).toEqual(fixture['data']['id']);
+
+	expect(transaction).toBeInstanceOf(Vote);
+});
+
+it('should deserialize a unvote signed with a passphrase', async () => {
+	const fixture = await getFixture('unvote');
+
+	const transaction = assertDeserialized(fixture, ['id', 'nonce', 'gasPrice', 'gasLimit', 'value', 'v', 'r', 's']);
+
+	expect(transaction).toBeInstanceOf(Unvote);
+});
+
+it('should deserialize a validator registration signed with a passphrase', async () => {
+	const fixture = await getFixture('validator-registration');
+
+	const transaction = assertDeserialized(fixture, ['id', 'nonce', 'gasPrice', 'gasLimit', 'value', 'v', 'r', 's']);
+
+	expect(transaction).toBeInstanceOf(ValidatorRegistration);
+});
+
+it('should deserialize a validator resignation signed with a passphrase', async () => {
+	const fixture = await getFixture('validator-resignation');
+
+	const transaction = assertDeserialized(fixture, ['id', 'nonce', 'gasPrice', 'gasLimit', 'value', 'v', 'r', 's']);
+
+	expect(transaction).toBeInstanceOf(ValidatorResignation);
+});
+
+it('should deserialize a username registration signed with a passphrase', async () => {
+	const fixture = await getFixture('username-registration');
+
+	const transaction = assertDeserialized(fixture, ['id', 'nonce', 'gasPrice', 'gasLimit', 'value', 'v', 'r', 's']);
+
+	expect(transaction).toBeInstanceOf(UsernameRegistration);
+});
+
+it('should deserialize a username resignation signed with a passphrase', async () => {
+	const fixture = await getFixture('username-resignation');
+
+	const transaction = assertDeserialized(fixture, ['id', 'nonce', 'gasPrice', 'gasLimit', 'value', 'v', 'r', 's']);
+
+	expect(transaction).toBeInstanceOf(UsernameResignation);
+});
+
+it('should deserialize a multipayment signed with a passphrase', async () => {
+	const fixture = await getFixture('multipayment');
+
+	const transaction = assertDeserialized(fixture, ['id', 'nonce', 'gasPrice', 'gasLimit', 'value', 'v', 'r', 's']);
+
+	expect(transaction).toBeInstanceOf(Multipayment);
+});
+
+it('should parse number', () => {
+    expect(Deserializer.parseNumber('0x01')).toEqual(1)
+    expect(Deserializer.parseNumber('0x0100')).toEqual(256)
+    expect(Deserializer.parseNumber('0x010000')).toEqual(65536);
+    expect(Deserializer.parseNumber('0x')).toEqual(0);
+});
+
+it('should parse hex', () => {
+    expect(Deserializer.parseHex('0x01')).toEqual('01');
+    expect(Deserializer.parseHex('0x0100')).toEqual('0100');
+    expect(Deserializer.parseHex('0x010000')).toEqual('010000');
+    expect(Deserializer.parseHex('0x')).toEqual('');
+    expect(Deserializer.parseHex('0x52B7D2DCC80CD2E4000000')).toEqual('52B7D2DCC80CD2E4000000');
+});
+
+it('should parse big_number', () => {
+    expect(Deserializer.parseBigNumber('0x01')).toEqual('1');
+    expect(Deserializer.parseBigNumber('0x0100')).toEqual('256');
+    expect(Deserializer.parseBigNumber('0x010000')).toEqual('65536');
+    expect(Deserializer.parseBigNumber('0x')).toEqual('0');
+    expect(Deserializer.parseBigNumber('0x52B7D2DCC80CD2E4000000')).toEqual('100000000000000000000000000');
+});
+
+it('should parse address', () => {
+    expect(Deserializer.parseAddress('0x52B7D2DCC80CD2E4000000')).toEqual('0x52B7D2DCC80CD2E4000000');
+    expect(Deserializer.parseAddress('0x')).toBe(undefined);
+});

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

@@ -0,0 +1,9 @@
+import fixtureTransfer from "@tests/fixtures/transactions/transfer.json";
+
+import { Transfer } from "@/transactions/types/Transfer";
+
+it("should serialize a transfer transaction", () => {
+	const transaction = new Transfer(fixtureTransfer.data);
+
+	expect(fixtureTransfer["serialized"]).toEqual(transaction.serialize().toString("binary"));
+});

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

@@ -0,0 +1,49 @@
+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()
+			.payload(fixture.data.data)
+			.recipientAddress(fixture.data.recipientAddress)
+			.nonce(fixture.data.nonce)
+			.gasPrice(fixture.data.gasPrice)
+			.gasLimit(fixture.data.gasLimit)
+			.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.gasLimit).toBe(fixture.data.gasLimit);
+	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	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.serialize().toString("binary")).toEqual(fixture.serialized);
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should sign a transaction", async () => {
+	const transaction = (await EvmCallBuilder.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.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.serialize().toString("binary")).toEqual(fixture.serialized);
+	expect(transaction.verify()).toBe(true);
+});

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

@@ -0,0 +1,99 @@
+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";
+
+it("should build a transaction", async () => {
+	const transaction = (
+		await MultipaymentBuilder.new()
+			.pay("0x6F0182a0cc707b055322CcF6d4CB6a5Aff1aEb22", "100000")
+			.pay("0xc3bbe9b1cee1ff85ad72b87414b0e9b7f2366763", "200000")
+			.gasPrice(fixture.data.gasPrice)
+			.gasLimit(fixture.data.gasLimit)
+			.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.gasLimit).toBe(fixture.data.gasLimit);
+	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	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.serialize().toString("binary")).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;
+
+	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.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.serialize().toString("binary")).toEqual(fixture.serialized);
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should build a transaction with a single payment", async () => {
+	const transaction = (
+		await MultipaymentBuilder.new()
+			.pay("0x6F0182a0cc707b055322CcF6d4CB6a5Aff1aEb22", "100000")
+			.gasPrice(fixtureSingle.data.gasPrice)
+			.gasLimit(fixtureSingle.data.gasLimit)
+			.network(fixtureSingle.data.network)
+			.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.gasLimit).toBe(fixtureSingle.data.gasLimit);
+	expect(transaction.data.recipientAddress).toBe(fixtureSingle.data.recipientAddress);
+	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.serialize().toString("binary")).toEqual(fixtureSingle.serialized);
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should build a transaction with an empty payment", async () => {
+	const transaction = (
+		await MultipaymentBuilder.new()
+			.gasPrice(fixtureEmpty.data.gasPrice)
+			.gasLimit(fixtureEmpty.data.gasLimit)
+			.network(fixtureEmpty.data.network)
+			.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.gasLimit).toBe(fixtureEmpty.data.gasLimit);
+	expect(transaction.data.recipientAddress).toBe(fixtureEmpty.data.recipientAddress);
+	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.serialize().toString("binary")).toEqual(fixtureEmpty.serialized);
+	expect(transaction.verify()).toBe(true);
+});

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

@@ -0,0 +1,73 @@
+import fixtureTransfer 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";
+
+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("binary")).toEqual(fixtureTransfer.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("binary")).toEqual(fixtureTransfer.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;
+
+	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.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.serialize().toString("binary")).toEqual(fixtureTransferLargeAmount.serialized);
+	expect(transaction.verify()).toBe(true);
+});

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

@@ -0,0 +1,47 @@
+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)
+			.gasLimit(fixture.data.gasLimit)
+			.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.gasLimit).toBe(fixture.data.gasLimit);
+	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	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.serialize().toString("binary")).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;
+
+	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.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.serialize().toString("binary")).toEqual(fixture.serialized);
+	expect(transaction.verify()).toBe(true);
+});

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

@@ -0,0 +1,54 @@
+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";
+
+it("should build a transaction", async () => {
+	const transaction = (
+		await UsernameRegistrationBuilder.new()
+			.username("fixture")
+			.nonce(fixture.data.nonce)
+			.gasPrice(fixture.data.gasPrice)
+			.gasLimit(fixture.data.gasLimit)
+			.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.gasLimit).toBe(fixture.data.gasLimit);
+	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	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.serialize().toString("binary")).toEqual(fixture.serialized);
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should sign a transaction", async () => {
+	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.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.serialize().toString("binary")).toEqual(fixture.serialized);
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should throw if username is invalid", async () => {
+	expect(() => UsernameRegistrationBuilder.new().username("invalid.username.too.long")).toThrow();
+});

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

@@ -0,0 +1,48 @@
+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)
+			.gasLimit(fixture.data.gasLimit)
+			.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.gasLimit).toBe(fixture.data.gasLimit);
+	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	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.serialize().toString("binary")).toEqual(fixture.serialized);
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should sign a transaction", async () => {
+	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.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.serialize().toString("binary")).toEqual(fixture.serialized);
+	expect(transaction.verify()).toBe(true);
+});

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

@@ -0,0 +1,51 @@
+import fixture from "@tests/fixtures/transactions/validator-registration.json";
+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(
+				"0x30954f46d6097a1d314e900e66e11e0dad0a57cd03e04ec99f0dedd1c765dcb11e6d7fa02e22cf40f9ee23d9cc1c0624",
+			)
+			.nonce(fixture.data.nonce)
+			.gasPrice(fixture.data.gasPrice)
+			.gasLimit(fixture.data.gasLimit)
+			.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.gasLimit).toBe(fixture.data.gasLimit);
+	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	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.serialize().toString("binary")).toEqual(fixture.serialized);
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should sign a transaction", async () => {
+	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.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.serialize().toString("binary")).toEqual(fixture.serialized);
+	expect(transaction.verify()).toBe(true);
+});