@arkecosystem/typescript-crypto 0.0.1

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

@@ -0,0 +1,48 @@
+import fixture from "@tests/fixtures/transactions/validator-resignation.json";
+import identityFixture from "@tests/fixtures/identity.json";
+
+import { ValidatorResignationBuilder } from "@/transactions/builders/ValidatorResignationBuilder";
+
+it("should build a transaction", async () => {
+	const transaction = (
+		await ValidatorResignationBuilder.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 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.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/VoteBuilder.test.ts

@@ -0,0 +1,48 @@
+import fixture from "@tests/fixtures/transactions/vote.json";
+import identityFixture from "@tests/fixtures/identity.json";
+
+import { VoteBuilder } from "@/transactions/builders/VoteBuilder";
+
+it("should build a transaction", async () => {
+	const transaction = (
+		await VoteBuilder.new()
+			.vote("0xc3bbe9b1cee1ff85ad72b87414b0e9b7f2366763")
+			.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 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.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/types/AbstractTransaction.test.ts

@@ -0,0 +1,145 @@
+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";
+	}
+}
+
+it("should create a new instance", () => {
+	const transaction = new Transaction({});
+
+	expect(transaction).toBeInstanceOf(Transaction);
+	expect(transaction).toBeInstanceOf(AbstractTransaction);
+
+	expect(transaction.data).toEqual({
+		data: "7061796C6F6164",
+	});
+});
+
+it("should get payload", () => {
+	const transaction = new Transaction({});
+
+	expect(transaction.getPayload()).toEqual("7061796C6F6164");
+});
+
+it("should refresh the payload", () => {
+	const transaction = new Transaction({});
+	transaction.getPayload = () => "updated-payload";
+
+	expect(transaction.data.data).toEqual("7061796C6F6164");
+
+	transaction.refreshPayloadData();
+
+	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);
+
+	transaction.sign(privateKey);
+
+	expect(transaction.data.v).toEqual(fixture.data.v);
+	expect(transaction.data.r).toEqual(fixture.data.r);
+	expect(transaction.data.s).toEqual(fixture.data.s);
+});
+
+it("should recover the sender", () => {
+	const transaction = new Transfer(fixture.data);
+
+	transaction.recoverSender();
+
+	expect(transaction.data.senderPublicKey).toEqual(fixture.data.senderPublicKey);
+	expect(transaction.data.senderAddress).toEqual(fixture.data.senderAddress);
+});
+
+it("should verify the transaction", () => {
+	const transaction = new Transfer(fixture.data);
+
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should convert the transaction to json", () => {
+	const transaction = new Transaction(fixture.data);
+
+	expect(transaction.toJson()).toEqual(
+		JSON.stringify({
+			gasPrice: fixture.data["gasPrice"],
+			network: fixture.data["network"],
+			id: fixture.data["id"],
+			gasLimit: fixture.data["gasLimit"],
+			nonce: fixture.data["nonce"],
+			senderPublicKey: fixture.data["senderPublicKey"],
+			recipientAddress: fixture.data["recipientAddress"],
+			value: fixture.data["value"],
+			data: "7061796C6F6164",
+			r: fixture.data["r"],
+			s: fixture.data["s"],
+			v: fixture.data["v"],
+		}),
+	);
+});
+
+it("should generate a hash for the transaction with signature", () => {
+	const transaction = new Transfer(fixture.data);
+
+	expect(transaction.hash()).toEqual(fixture.data.id);
+});
+
+it("should generate a hash for the transaction without signature", () => {
+	const transaction = new Transfer(fixture.data);
+
+	const hash = transaction.hash(true);
+
+	expect(typeof hash).toBe("string");
+	expect(hash).toHaveLength(64);
+});
+
+it("should serialize the transaction with signature", () => {
+	const transaction = new Transfer(fixture.data);
+
+	expect(transaction.serialize().toString("binary")).toBe(fixture.serialized);
+});
+
+it("should serialize the transaction without signature", () => {
+	const transaction = new Transfer(fixture.data);
+
+	const serialized = transaction.serialize(true).toString("binary");
+
+	expect(serialized).toHaveLength(88);
+
+	// 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/utils/Abi/ArgumentDecoder.test.ts

@@ -0,0 +1,55 @@
+import { ArgumentDecoder } from "@/utils/Abi/ArgumentDecoder";
+
+it('should decode string', () => {
+	const payload = '0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000D48656C6C6F2C20776F726C642100000000000000000000000000000000000000';
+	const expected = 'Hello, world!';
+
+	const decoder = new ArgumentDecoder(payload);
+
+	expect(decoder.decodeString()).toEqual(expected);
+});
+
+it('should decode address', () => {
+	const payload = '000000000000000000000000512F366D524157BcF734546eB29a6d687B762255';
+	const expected = '0x512F366D524157BcF734546eB29a6d687B762255';
+
+	const decoder = new ArgumentDecoder(payload);
+
+	expect(decoder.decodeAddress()).toEqual(expected);
+});
+
+it('should decode unsigned int', () => {
+	const payload = '000000000000000000000000000000000000000000000000016345785d8a0000';
+	const expected = '100000000000000000';
+
+	const decoder = new ArgumentDecoder(payload);
+
+	expect(decoder.decodeUnsignedInt()).toEqual(expected);
+});
+
+it('should decode signed int', () => {
+	const payload = '000000000000000000000000000000000000000000000000016345785d8a0000';
+	const expected = '100000000000000000';
+
+	const decoder = new ArgumentDecoder(payload);
+
+	expect(decoder.decodeSignedInt()).toEqual(expected);
+});
+
+it('should decode bool as true', () => {
+	const payload = '0000000000000000000000000000000000000000000000000000000000000001';
+	const expected = true;
+
+	const decoder = new ArgumentDecoder(payload);
+
+	expect(decoder.decodeBool()).toEqual(expected);
+});
+
+it('should decode bool as false', () => {
+	const payload = '0000000000000000000000000000000000000000000000000000000000000000';
+	const expected = false;
+
+	const decoder = new ArgumentDecoder(payload);
+
+	expect(decoder.decodeBool()).toEqual(expected);
+});

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

@@ -0,0 +1,44 @@
+import { AbiDecoder } from "@/utils/AbiDecoder";
+import { ContractAbiType } from "@/enums/ContractAbiType";
+
+it("should decode a vote function call", () => {
+	const decoder = new AbiDecoder();
+
+	const args = ["0x512F366D524157BcF734546eB29a6d687B762255"];
+	const data = "6dd7d8ea000000000000000000000000512f366d524157bcf734546eb29a6d687b762255";
+
+	const decodedData = decoder.decodeFunctionData(data);
+
+	expect(decodedData.args[0]).toBe(args[0]);
+});
+
+it("should decode an unvote function call", () => {
+	const decoder = new AbiDecoder();
+
+	const data = "3174b689";
+
+	const decodedData = decoder.decodeFunctionData(data);
+
+	expect(decodedData.functionName).toEqual("unvote");
+	expect(decodedData.args).toEqual([]);
+});
+
+it("should decode a multipayment function call", () => {
+	const decoder = new AbiDecoder(ContractAbiType.MULTIPAYMENT);
+
+	const args = [
+		["0xb693449AdDa7EFc015D87944EAE8b7C37EB1690A", "0xb693449AdDa7EFc015D87944EAE8b7C37EB1690A"],
+		["100000000", "200000000"],
+	];
+	const data =
+		"084ce708000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000b693449adda7efc015d87944eae8b7c37eb1690a000000000000000000000000b693449adda7efc015d87944eae8b7c37eb1690a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000005f5e100000000000000000000000000000000000000000000000000000000000bebc200";
+
+	const decodedData = decoder.decodeFunctionData(data);
+
+	expect(decodedData.args[0]).toEqual(args[0]);
+	expect(decodedData.args[1].map((value: BigInt) => value.toString())).toEqual(args[1]);
+});
+
+it("should throw an error if custom abi is not passed", () => {
+	expect(() => new AbiDecoder(ContractAbiType.CUSTOM)).toThrow("Invalid contract type");
+});

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

@@ -0,0 +1,30 @@
+import { AbiEncoder } from "@/utils/AbiEncoder";
+import { ContractAbiType } from "@/enums/ContractAbiType";
+
+it("should encode a vote function call", () => {
+	const encoder = new AbiEncoder();
+
+	const functionName = "vote";
+	const args = ["0x512F366D524157BcF734546eB29a6d687B762255"];
+	const expectedEncodedData = "0x6dd7d8ea000000000000000000000000512f366d524157bcf734546eb29a6d687b762255";
+
+	const encodedData = encoder.encodeFunctionCall(functionName, args);
+
+	expect(encodedData).toBe(expectedEncodedData);
+});
+
+it("should encode a multipayment function call", () => {
+	const encoder = new AbiEncoder(ContractAbiType.MULTIPAYMENT);
+
+	const functionName = "pay";
+	const args = [
+		["0xb693449AdDa7EFc015D87944EAE8b7C37EB1690A", "0xb693449AdDa7EFc015D87944EAE8b7C37EB1690A"],
+		["100000000", "200000000"],
+	];
+	const expectedEncodedData =
+		"0x084ce708000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000b693449adda7efc015d87944eae8b7c37eb1690a000000000000000000000000b693449adda7efc015d87944eae8b7c37eb1690a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000005f5e100000000000000000000000000000000000000000000000000000000000bebc200";
+
+	const encodedData = encoder.encodeFunctionCall(functionName, args);
+
+	expect(encodedData).toBe(expectedEncodedData);
+});

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

@@ -0,0 +1,120 @@
+import { Helpers } from "@/utils/Helpers";
+import { InvalidUsernameException } from "@/exceptions/InvalidUsernameException";
+
+describe("Helpers", () => {
+	describe("isValidUsername", () => {
+		it("should return true for valid usernames", () => {
+			const validUsernames = [
+				"username",
+				"user123",
+				"user_name",
+				"a",
+				"user_name_123",
+				"123456789012345678", // 18 chars
+				"abcdefghijklmnopqrst", // 20 chars
+			];
+
+			validUsernames.forEach((username) => {
+				expect(Helpers.isValidUsername(username)).toBe(true);
+			});
+		});
+
+		it("should throw exception for usernames that are too short", () => {
+			expect(() => {
+				Helpers.isValidUsername("");
+			}).toThrow(InvalidUsernameException);
+
+			expect(() => {
+				Helpers.isValidUsername("");
+			}).toThrow("Username must be between 1 and 20 characters long. Got 0 characters.");
+		});
+
+		it("should throw exception for usernames that are too long", () => {
+			const tooLongUsername = "abcdefghijklmnopqrstu"; // 21 chars
+
+			expect(() => {
+				Helpers.isValidUsername(tooLongUsername);
+			}).toThrow(InvalidUsernameException);
+
+			expect(() => {
+				Helpers.isValidUsername(tooLongUsername);
+			}).toThrow("Username must be between 1 and 20 characters long. Got 21 characters.");
+		});
+
+		it("should throw exception for usernames with invalid characters", () => {
+			const invalidUsernames = [
+				"User", // uppercase
+				"user-name", // hyphen
+				"user.name", // period
+				"user name", // space
+				"user@name", // special char
+				"useñame", // non-ASCII
+			];
+
+			invalidUsernames.forEach((username) => {
+				expect(() => {
+					Helpers.isValidUsername(username);
+				}).toThrow(InvalidUsernameException);
+
+				expect(() => {
+					Helpers.isValidUsername(username);
+				}).toThrow("Username can only contain lowercase letters, numbers and underscores.");
+			});
+		});
+
+		it("should throw exception for usernames starting with underscore", () => {
+			expect(() => {
+				Helpers.isValidUsername("_username");
+			}).toThrow(InvalidUsernameException);
+
+			expect(() => {
+				Helpers.isValidUsername("_username");
+			}).toThrow("Username cannot start or end with an underscore.");
+		});
+
+		it("should throw exception for usernames ending with underscore", () => {
+			expect(() => {
+				Helpers.isValidUsername("username_");
+			}).toThrow(InvalidUsernameException);
+
+			expect(() => {
+				Helpers.isValidUsername("username_");
+			}).toThrow("Username cannot start or end with an underscore.");
+		});
+
+		it("should throw exception for usernames with consecutive underscores", () => {
+			expect(() => {
+				Helpers.isValidUsername("user__name");
+			}).toThrow(InvalidUsernameException);
+
+			expect(() => {
+				Helpers.isValidUsername("user__name");
+			}).toThrow("Username cannot contain consecutive underscores.");
+		});
+	});
+
+	describe("removeLeadingHexZero", () => {
+		it("should remove the 0x prefix from hex strings", () => {
+			expect(Helpers.removeLeadingHexZero("0x1234")).toBe("1234");
+			expect(Helpers.removeLeadingHexZero("0x0123")).toBe("0123");
+			expect(Helpers.removeLeadingHexZero("0xabcdef")).toBe("abcdef");
+		});
+
+		it("should return the original string if no 0x prefix is present", () => {
+			expect(Helpers.removeLeadingHexZero("1234")).toBe("1234");
+			expect(Helpers.removeLeadingHexZero("0123")).toBe("0123");
+			expect(Helpers.removeLeadingHexZero("")).toBe("");
+		});
+
+		it("should only remove the prefix, not leading zeros", () => {
+			expect(Helpers.removeLeadingHexZero("0x0000")).toBe("0000");
+			expect(Helpers.removeLeadingHexZero("0x0001")).toBe("0001");
+		});
+
+		it("should handle edge cases", () => {
+			expect(Helpers.removeLeadingHexZero("0x")).toBe("");
+			expect(Helpers.removeLeadingHexZero("x0x1234")).toBe("x0x1234");
+			expect(Helpers.removeLeadingHexZero("0X1234")).toBe("0X1234"); // case sensitive
+		});
+	});
+});

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

@@ -0,0 +1,104 @@
+import { Message } from "@/utils/Message";
+
+describe("Message", () => {
+	const getFixture = async (name: string) => {
+		return (await import(`@tests/fixtures/${name}.json`)).default;
+	};
+
+	describe("sign", () => {
+		it("should sign a valid message", async () => {
+			const fixture = await getFixture("message-sign");
+			const passphrase = (await getFixture("global")).passphrase;
+
+			const message = await Message.sign(fixture.message, passphrase);
+
+			expect(message.publicKey).toBe(fixture.publicKey);
+			expect(message.signature).toBe(fixture.signature);
+			expect(message.message).toBe(fixture.message);
+		});
+
+		it("should sign a message", async () => {
+			const message = await Message.sign("Hello World", "passphrase");
+
+			expect(message).toBeInstanceOf(Message);
+		});
+	});
+
+	describe("new", () => {
+		it("should create a message from an object", async () => {
+			const fixture = await getFixture("message-sign");
+
+			const message = Message.new(fixture);
+
+			expect(message.publicKey).toBe(fixture.publicKey);
+			expect(message.signature).toBe(fixture.signature);
+			expect(message.message).toBe(fixture.message);
+		});
+
+		it("should create a message from a string", async () => {
+			const fixture = await getFixture("message-sign");
+			const jsonString = JSON.stringify(fixture);
+
+			const message = Message.new(JSON.parse(jsonString));
+
+			expect(message.publicKey).toBe(fixture.publicKey);
+			expect(message.signature).toBe(fixture.signature);
+			expect(message.message).toBe(fixture.message);
+		});
+	});
+
+	describe("verify", () => {
+		it("should verify a signed message", async () => {
+			const message = await Message.sign("Hello World", "passphrase");
+
+			expect(message.verify()).toBe(true);
+		});
+
+		it("should verify a message", async () => {
+			const message = Message.new(await getFixture("message-sign"));
+
+			expect(message.verify()).toBe(true);
+		});
+
+		it("should not verify an invalid message", async () => {
+			const message = Message.new(await getFixture("message-sign"));
+			message.publicKey = "034151a3ec46b5670a682b0a63394f863587d1bc97483b1b6c70eb58e7f0aed192";
+
+			expect(message.verify()).toBe(false);
+		});
+	});
+
+	describe("serialization", () => {
+		it("should turn a message into an array", async () => {
+			const message = Message.new(await getFixture("message-sign"));
+			const array = message.toArray();
+
+			expect(Array.isArray(array)).toBe(true);
+			expect(array.length).toBe(3);
+			expect(array[0]).toBe(message.publicKey);
+			expect(array[1]).toBe(message.signature);
+			expect(array[2]).toBe(message.message);
+		});
+
+		it("should turn a message into JSON", async () => {
+			const message = Message.new(await getFixture("message-sign"));
+			const json = message.toJson();
+
+			expect(typeof json).toBe("object");
+			expect(json.publicKey).toBe(message.publicKey);
+			expect(json.signature).toBe(message.signature);
+			expect(json.message).toBe(message.message);
+		});
+
+		it("should turn a message into a string", async () => {
+			const message = Message.new(await getFixture("message-sign"));
+			const str = message.toString();
+
+			expect(typeof str).toBe("string");
+			const parsed = JSON.parse(str);
+			expect(parsed.publicKey).toBe(message.publicKey);
+			expect(parsed.signature).toBe(message.signature);
+			expect(parsed.message).toBe(message.message);
+		});
+	});
+});

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

@@ -0,0 +1,69 @@
+import { Network } from "@/configuration/Network";
+import { Slot } from "@/utils/Slot";
+import { Testnet } from "@/networks/Testnet";
+import { jest } from "@jest/globals";
+
+// Mock date implementation to have consistent tests
+const mockDate = new Date("2023-01-01T12:00:00.000Z");
+
+describe("Slot", () => {
+	beforeAll(() => {
+		jest.spyOn(Network, "get").mockReturnValue(new Testnet());
+		jest.spyOn(Date, "now").mockImplementation(() => mockDate.getTime());
+	});
+
+	afterAll(() => {
+		jest.restoreAllMocks();
+	});
+
+	describe("epoch", () => {
+		it("should return the epoch timestamp in seconds", () => {
+			// Testnet epoch is "2017-03-21T13:00:00.000Z"
+			const epochTimestamp = Math.floor(new Date("2017-03-21T13:00:00.000Z").getTime() / 1000);
+
+			expect(Slot.epoch()).toBe(epochTimestamp);
+		});
+	});
+
+	describe("time", () => {
+		it("should return the number of seconds that have passed since network epoch", () => {
+			// Calculate expected time: current timestamp minus epoch timestamp (in seconds)
+			const currentTimestamp = Math.floor(mockDate.getTime() / 1000);
+			const epochTimestamp = Math.floor(new Date("2017-03-21T13:00:00.000Z").getTime() / 1000);
+			const expectedTime = currentTimestamp - epochTimestamp;
+
+			expect(Slot.time()).toBe(expectedTime);
+		});
+
+		it("should update when time changes", () => {
+			const time1 = Slot.time();
+
+			// Change the mocked current time (+1 hour)
+			const newMockDate = new Date(mockDate);
+			newMockDate.setHours(newMockDate.getHours() + 1);
+			jest.spyOn(Date, "now").mockImplementation(() => newMockDate.getTime());
+
+			// Second call with new time
+			const time2 = Slot.time();
+
+			// Difference should be 3600 seconds (1 hour)
+			expect(time2 - time1).toBe(3600);
+
+			// Reset the mock
+			jest.spyOn(Date, "now").mockImplementation(() => mockDate.getTime());
+		});
+
+		it("should calculate correct time with Testnet configuration", () => {
+			expect(Network.get().chainId()).toBe(10000);
+
+			const actualEpochTime = Slot.epoch();
+			const actualSlotTime = Slot.time();
+
+			const currentTimestamp = Math.floor(mockDate.getTime() / 1000);
+			expect(actualSlotTime).toBe(currentTimestamp - actualEpochTime);
+
+			const testnetEpochTimestamp = Math.floor(new Date("2017-03-21T13:00:00.000Z").getTime() / 1000);
+			expect(actualEpochTime).toBe(testnetEpochTimestamp);
+		});
+	});
+});