@arkecosystem/typescript-crypto 0.0.4 → 0.0.6

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/AbiDecoder.test.ts

@@ -1,5 +1,6 @@
 import { AbiDecoder } from "@/utils/AbiDecoder";
 import { ContractAbiType } from "@/enums/ContractAbiType";
+import MultipaymentAbi from "@/utils/Abi/json/Abi.Multipayment.json";
 
 it("should decode a vote function call", () => {
 	const decoder = new AbiDecoder();
@@ -23,8 +24,13 @@ it("should decode an unvote function call", () => {
 	expect(decodedData.args).toEqual([]);
 });
 
-it("should decode a multipayment function call", () => {
-	const decoder = new AbiDecoder(ContractAbiType.MULTIPAYMENT);
+it("should throw an error if custom abi is not passed", () => {
+	expect(() => new AbiDecoder(ContractAbiType.CUSTOM)).toThrow("Invalid contract type");
+});
+
+// We'll re-use the multipayment contract for this test
+it("should decode using a custom abi", () => {
+	const decoder = new AbiDecoder(ContractAbiType.CUSTOM, MultipaymentAbi);
 
 	const args = [
 		["0xb693449AdDa7EFc015D87944EAE8b7C37EB1690A", "0xb693449AdDa7EFc015D87944EAE8b7C37EB1690A"],
@@ -38,7 +44,3 @@ it("should decode a multipayment function call", () => {
 	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

@@ -1,12 +1,13 @@
 import { AbiEncoder } from "@/utils/AbiEncoder";
 import { ContractAbiType } from "@/enums/ContractAbiType";
+import MultipaymentAbi from "@/utils/Abi/json/Abi.Multipayment.json";
 
 it("should encode a vote function call", () => {
 	const encoder = new AbiEncoder();
 
 	const functionName = "vote";
 	const args = ["0x512F366D524157BcF734546eB29a6d687B762255"];
-	const expectedEncodedData = "0x6dd7d8ea000000000000000000000000512f366d524157bcf734546eb29a6d687b762255";
+	const expectedEncodedData = "6dd7d8ea000000000000000000000000512f366d524157bcf734546eb29a6d687b762255";
 
 	const encodedData = encoder.encodeFunctionCall(functionName, args);
 
@@ -22,7 +23,24 @@ it("should encode a multipayment function call", () => {
 		["100000000", "200000000"],
 	];
 	const expectedEncodedData =
-		"0x084ce708000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000b693449adda7efc015d87944eae8b7c37eb1690a000000000000000000000000b693449adda7efc015d87944eae8b7c37eb1690a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000005f5e100000000000000000000000000000000000000000000000000000000000bebc200";
+		"084ce708000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000b693449adda7efc015d87944eae8b7c37eb1690a000000000000000000000000b693449adda7efc015d87944eae8b7c37eb1690a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000005f5e100000000000000000000000000000000000000000000000000000000000bebc200";
+
+	const encodedData = encoder.encodeFunctionCall(functionName, args);
+
+	expect(encodedData).toBe(expectedEncodedData);
+});
+
+// We'll re-use the multipayment contract for this test
+it("should encode using a custom abi", () => {
+	const encoder = new AbiEncoder(ContractAbiType.CUSTOM, MultipaymentAbi);
+
+	const functionName = "pay";
+	const args = [
+		["0xb693449AdDa7EFc015D87944EAE8b7C37EB1690A", "0xb693449AdDa7EFc015D87944EAE8b7C37EB1690A"],
+		["100000000", "200000000"],
+	];
+	const expectedEncodedData =
+		"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

@@ -1,5 +1,4 @@
 import fixture from "@tests/fixtures/transactions/transfer.json";
-
 import { TransactionUtils } from "@/utils/TransactionUtils";
 
 it("should convert a transaction to a buffer with a signature", () => {
@@ -15,8 +14,36 @@ it("should convert a transaction to a buffer without a signature", () => {
 	expect(buffer).toBeInstanceOf(Buffer);
 });
 
+it("should convert a transaction to a buffer using fallback values if missing", () => {
+	const result = TransactionUtils.toBuffer({
+		network: undefined,
+		nonce: undefined,
+		gasPrice: undefined,
+		gasLimit: undefined,
+		recipientAddress: undefined,
+		value: undefined,
+		data: undefined,
+	}).toString("hex");
+
+	expect(result).toEqual("02c98080808080808080c0");
+});
+
+it("should convert a transaction to a buffer handling data starting with 0x", () => {
+	const result = TransactionUtils.toBuffer({
+		network: undefined,
+		nonce: undefined,
+		gasPrice: undefined,
+		gasLimit: undefined,
+		recipientAddress: undefined,
+		value: undefined,
+		data: "0x1234567890",
+	}).toString("hex");
+
+	expect(result).toEqual("02ce80808080808080851234567890c0");
+});
+
 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 +52,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);
+
+	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);
 
-	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,
-};