@arkecosystem/typescript-crypto 0.0.3 → 0.0.5

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/tests/unit/utils/Abi/ArgumentDecoder.test.ts

@@ -1,43 +1,44 @@
 import { ArgumentDecoder } from "@/utils/Abi/ArgumentDecoder";
 
-it('should decode string', () => {
-	const payload = '0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000D48656C6C6F2C20776F726C642100000000000000000000000000000000000000';
-	const expected = 'Hello, world!';
+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';
+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';
+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';
+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';
+it("should decode bool as true", () => {
+	const payload = "0000000000000000000000000000000000000000000000000000000000000001";
 	const expected = true;
 
 	const decoder = new ArgumentDecoder(payload);
@@ -45,8 +46,8 @@ it('should decode bool as true', () => {
 	expect(decoder.decodeBool()).toEqual(expected);
 });
 
-it('should decode bool as false', () => {
-	const payload = '0000000000000000000000000000000000000000000000000000000000000000';
+it("should decode bool as false", () => {
+	const payload = "0000000000000000000000000000000000000000000000000000000000000000";
 	const expected = false;
 
 	const decoder = new ArgumentDecoder(payload);

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

@@ -6,7 +6,7 @@ it("should encode a vote function call", () => {
 
 	const functionName = "vote";
 	const args = ["0x512F366D524157BcF734546eB29a6d687B762255"];
-	const expectedEncodedData = "0x6dd7d8ea000000000000000000000000512f366d524157bcf734546eb29a6d687b762255";
+	const expectedEncodedData = "6dd7d8ea000000000000000000000000512f366d524157bcf734546eb29a6d687b762255";
 
 	const encodedData = encoder.encodeFunctionCall(functionName, args);
 
@@ -22,7 +22,7 @@ it("should encode a multipayment function call", () => {
 		["100000000", "200000000"],
 	];
 	const expectedEncodedData =
-		"0x084ce708000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000b693449adda7efc015d87944eae8b7c37eb1690a000000000000000000000000b693449adda7efc015d87944eae8b7c37eb1690a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000005f5e100000000000000000000000000000000000000000000000000000000000bebc200";
+		"084ce708000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000b693449adda7efc015d87944eae8b7c37eb1690a000000000000000000000000b693449adda7efc015d87944eae8b7c37eb1690a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000005f5e100000000000000000000000000000000000000000000000000000000000bebc200";
 
 	const encodedData = encoder.encodeFunctionCall(functionName, args);
 

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

@@ -71,7 +71,7 @@ describe("Message", () => {
 	describe("serialization", () => {
 		it("should turn a message into an array", async () => {
 			const message = Message.new(await getFixture("message-sign"));
-			const array = message.toArray();
+			const array = message.toObject();
 
 			expect(Array.isArray(array)).toBe(true);
 			expect(array.length).toBe(3);

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

@@ -16,7 +16,7 @@ it("should convert a transaction to a buffer without a signature", () => {
 });
 
 it("should convert a transaction to a hash with a signature", () => {
-	expect(TransactionUtils.toHash(fixture.data)).toBe(fixture.data.id);
+	expect(TransactionUtils.toHash(fixture.data)).toBe(fixture.data.hash);
 });
 
 it("should convert a transaction to a hash without a signature", () => {
@@ -25,7 +25,3 @@ it("should convert a transaction to a hash without a signature", () => {
 	expect(typeof hash).toBe("string");
 	expect(hash).toHaveLength(64);
 });
-
-it("should get a transaction id", () => {
-	expect(TransactionUtils.getId(fixture.data)).toBe(fixture.data.id);
-});

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

@@ -1,71 +1,105 @@
 import { UnitConverter } from "@/utils/UnitConverter";
 
-it('should parse units into wei', () => {
-	const weiValue = UnitConverter.parseUnits(1, 'wei');
-
-	expect(weiValue.toString()).toEqual('1');
+it.each([
+	[1, "1"],
+	[10, "10"],
+	[100, "100"],
+	[1000, "1000"],
+	[10000, "10000"],
+])("should parse units into wei [%s]", (amount, formattedAmount) => {
+	const weiValue = UnitConverter.parseUnits(amount, "wei");
+
+	expect(weiValue.toString()).toEqual(formattedAmount);
 });
 
-it('should parse units into gwei', () => {
-	const gweiValue = UnitConverter.parseUnits(1, 'gwei');
-
-	expect(gweiValue.toString()).toEqual('1000000000');
+it.each([
+	[0.01, "10000000"],
+	[0.1, "100000000"],
+	[1, "1000000000"],
+	[10, "10000000000"],
+	[100, "100000000000"],
+	[1000, "1000000000000"],
+	[10000, "10000000000000"],
+])("should parse units into gwei [%s]", (amount, formattedAmount) => {
+	const gweiValue = UnitConverter.parseUnits(amount, "gwei");
+
+	expect(gweiValue.toString()).toEqual(formattedAmount);
 });
 
-it('should parse units into ark', () => {
-	const arkValue = UnitConverter.parseUnits(1, 'ark');
-
-	expect(arkValue.toString()).toEqual('1000000000000000000');
+it.each([
+	[0.01, "10000000000000000"],
+	[0.1, "100000000000000000"],
+	[1, "1000000000000000000"],
+	[10, "10000000000000000000"],
+	[100, "100000000000000000000"],
+	[1000, "1000000000000000000000"],
+	[10000, "10000000000000000000000"],
+])("should parse units into ark [%s]", (amount, formattedAmount) => {
+	const arkValue = UnitConverter.parseUnits(amount, "ark");
+
+	expect(arkValue.toFixed()).toEqual(formattedAmount);
 });
 
-it('should parse decimal units into ark', () => {
-	const arkValueDecimal = UnitConverter.parseUnits(0.1, 'ark');
+it.each([
+	["1", 1],
+	["10", 10],
+	["100", 100],
+	["1000", 1000],
+	["10000", 10000],
+])("should format units from wei [%s]", (formattedAmount, amount) => {
+	const formattedValue = UnitConverter.formatUnits(formattedAmount, "wei");
 
-	expect(arkValueDecimal.toString()).toEqual('100000000000000000');
+	expect(formattedValue).toEqual(amount);
 });
 
-it('should format units from wei', () => {
-	const formattedValue = UnitConverter.formatUnits('1', 'wei');
+it.each([
+	["1000000000", 1],
+	["10000000000", 10],
+	["100000000000", 100],
+	["1000000000000", 1000],
+	["10000000000000", 10000],
+])("should format units from gwei [%s]", (formattedAmount, amount) => {
+	const formattedValue = UnitConverter.formatUnits(formattedAmount, "gwei");
 
-	expect(formattedValue).toEqual(1.0);
+	expect(formattedValue).toEqual(amount);
 });
 
-it('should format units from gwei', () => {
-	const formattedValue = UnitConverter.formatUnits('1000000000', 'gwei');
+it.each([
+	["1000000000000000000", 1],
+	["10000000000000000000", 10],
+	["100000000000000000000", 100],
+	["1000000000000000000000", 1000],
+	["10000000000000000000000", 10000],
+])("should format units from ark [%s]", (formattedAmount, amount) => {
+	const formattedValue = UnitConverter.formatUnits(formattedAmount, "ark");
 
-	expect(formattedValue).toEqual(1.0);
+	expect(formattedValue).toEqual(amount);
 });
 
-it('should format units from ark', () => {
-	const formattedValue = UnitConverter.formatUnits('1000000000000000000', 'ark');
-
-	expect(formattedValue).toEqual(1.0);
+it("should throw exception for unsupported unit in parse", () => {
+	expect(() => UnitConverter.parseUnits(1, "unsupported")).toThrow(
+		"Unsupported unit: unsupported. Supported units are 'wei', 'gwei', and 'ark'.",
+	);
 });
 
-it('should throw exception for unsupported unit in parse', () => {
-	expect(() => UnitConverter.parseUnits(1, 'unsupported')).toThrow("Unsupported unit: unsupported. Supported units are 'wei', 'gwei', and 'ark'.");
-});
-
-it('should throw exception for unsupported unit in format', () => {
-	expect(() => UnitConverter.formatUnits('1', 'unsupported')).toThrow("Unsupported unit: unsupported. Supported units are 'wei', 'gwei', and 'ark'.");
-});
-
-it('should parse units into ark with fraction', () => {
-	const arkValue = UnitConverter.parseUnits(0.1, 'ark');
-
-	expect(arkValue.toString()).toEqual('100000000000000000');
+it("should throw exception for unsupported unit in format", () => {
+	expect(() => UnitConverter.formatUnits("1", "unsupported")).toThrow(
+		"Unsupported unit: unsupported. Supported units are 'wei', 'gwei', and 'ark'.",
+	);
 });
 
-it('should convert wei to ark', () => {
-	expect(UnitConverter.weiToArk(1, 'DARK')).toEqual('0.000000000000000001 DARK');
-	expect(UnitConverter.weiToArk(1)).toEqual('0.000000000000000001');
-	expect(UnitConverter.weiToArk('1000000000000000000', 'DARK')).toEqual('1 DARK');
-	expect(UnitConverter.weiToArk('1000000000000000000')).toEqual('1');
+it.each([
+	[1, "0.000000000000000001"],
+	["1000000000000000000", "1"],
+])("should convert wei to ark [%s]", (amount, formattedAmount) => {
+	expect(UnitConverter.weiToArk(amount, "DARK")).toEqual(`${formattedAmount} DARK`);
+	expect(UnitConverter.weiToArk(amount)).toEqual(formattedAmount);
 });
 
-it('should convert gwei to ark', () => {
-	expect(UnitConverter.gweiToArk(1, 'DARK')).toEqual('0.000000001 DARK');
-	expect(UnitConverter.gweiToArk(1)).toEqual('0.000000001');
-	expect(UnitConverter.gweiToArk('1000000000', 'DARK')).toEqual('1 DARK');
-	expect(UnitConverter.gweiToArk('1000000000')).toEqual('1');
+it.each([
+	[1, "0.000000001"],
+	["1000000000", "1"],
+])("should convert gwei to ark [%s]", (amount, formattedAmount) => {
+	expect(UnitConverter.gweiToArk(amount, "DARK")).toEqual(`${formattedAmount} DARK`);
+	expect(UnitConverter.gweiToArk(amount)).toEqual(formattedAmount);
 });

package/tsconfig.json

@@ -16,5 +16,5 @@
 		}
 	},
 	"include": ["src/**/*.ts"],
-	"exclude": ["node_modules/*", "dist/*"],
+	"exclude": ["node_modules/*", "dist/*"]
 }

package/.eslintrc.js

@@ -1,12 +0,0 @@
-module.exports = {
-	parser: "@typescript-eslint/parser",
-	plugins: ["@typescript-eslint"],
-	extends: [
-		"eslint:recommended",
-		"plugin:@typescript-eslint/recommended",
-		"prettier"
-	],
-	rules: {
-		"prettier/prettier": "error"
-	}
-};

package/prettier.config.js

@@ -1,8 +0,0 @@
-module.exports = {
-	semi: true,
-	trailingComma: "all",
-	singleQuote: false,
-	printWidth: 120,
-	useTabs: true,
-	tabWidth: 4,
-};