@arkecosystem/typescript-crypto 0.0.3 → 0.0.5

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

@@ -2,31 +2,31 @@ 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', () => {
+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', () => {
+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', () => {
+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', () => {
+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 () => {
+it("should sign compact correctly", async () => {
 	const privateKey = PrivateKey.fromPassphrase(fixtureSignCompact.passphrase);
 	const signature = await privateKey.sign(fixtureSignCompact.data.message);
 

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

@@ -4,36 +4,36 @@ 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', () => {
+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', () => {
+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', () => {
+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);
+	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', () => {
+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");
+	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

@@ -1,7 +1,7 @@
 import fixture from "@tests/fixtures/identity.json";
 import { WIF } from "@/identities/WIF";
 
-it('it should get the wif from passphrase', () => {
+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

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

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

@@ -1,9 +1,19 @@
 import fixtureTransfer from "@tests/fixtures/transactions/transfer.json";
 
 import { Transfer } from "@/transactions/types/Transfer";
+import { Serializer } from "../../../src/transactions/Serializer";
 
 it("should serialize a transfer transaction", () => {
 	const transaction = new Transfer(fixtureTransfer.data);
 
-	expect(fixtureTransfer["serialized"]).toEqual(transaction.serialize().toString("hex"));
+	expect(new Serializer(transaction).serialize().toString("hex")).toEqual(fixtureTransfer["serialized"]);
+});
+
+it("should serialize a transfer transaction without a signature", () => {
+	const transaction = new Transfer(fixtureTransfer.data);
+
+	// We slice the first few bytes because the serialization is different when the transaction is signed
+	expect(new Serializer(transaction).serialize(true).toString("hex").slice(4)).toEqual(
+		fixtureTransfer["serialized"].slice(6, 90),
+	);
 });

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

@@ -7,10 +7,10 @@ it("should build a transaction", async () => {
 	const transaction = (
 		await EvmCallBuilder.new()
 			.payload(fixture.data.data)
-			.recipientAddress(fixture.data.recipientAddress)
+			.to(fixture.data.to)
 			.nonce(fixture.data.nonce)
 			.gasPrice(fixture.data.gasPrice)
-			.gasLimit(fixture.data.gasLimit)
+			.gas(fixture.data.gas)
 			.network(fixture.data.network)
 			.sign(identityFixture.passphrase)
 	).transaction;
@@ -18,32 +18,99 @@ it("should build a transaction", async () => {
 	expect(transaction.data.gasPrice).toBe(fixture.data.gasPrice);
 	expect(transaction.data.nonce).toBe(fixture.data.nonce);
 	expect(transaction.data.network).toBe(fixture.data.network);
-	expect(transaction.data.gasLimit).toBe(fixture.data.gasLimit);
-	expect(transaction.data.recipientAddress).toBe(fixture.data.recipientAddress);
+	expect(transaction.data.gas).toBe(fixture.data.gas);
+	expect(transaction.data.to).toBe(fixture.data.to);
 	expect(transaction.data.value).toBe(fixture.data.value);
 	expect(transaction.data.v).toBe(fixture.data.v);
 	expect(transaction.data.r).toBe(fixture.data.r);
 	expect(transaction.data.s).toBe(fixture.data.s);
-	expect(transaction.data.id).toBe(fixture.data.id);
+	expect(transaction.data.hash).toBe(fixture.data.hash);
 
 	expect(transaction.serialize().toString("hex")).toEqual(fixture.serialized);
 	expect(transaction.verify()).toBe(true);
 });
 
 it("should sign a transaction", async () => {
-	const transaction = (await EvmCallBuilder.new(fixture.data).sign(identityFixture.passphrase)).transaction;
+	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.gas).toBe(fixture.data.gas);
+	expect(transaction.data.to).toBe(fixture.data.to);
 	expect(transaction.data.value).toBe(fixture.data.value);
 	expect(transaction.data.v).toBe(fixture.data.v);
 	expect(transaction.data.r).toBe(fixture.data.r);
 	expect(transaction.data.s).toBe(fixture.data.s);
-	expect(transaction.data.id).toBe(fixture.data.id);
+	expect(transaction.data.hash).toBe(fixture.data.hash);
 
 	expect(transaction.serialize().toString("hex")).toEqual(fixture.serialized);
 	expect(transaction.verify()).toBe(true);
 });
+
+it("should verify", async () => {
+	const transaction = await EvmCallBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.verify()).toBe(true);
+});
+
+it("should convert to an array", async () => {
+	const transaction = await EvmCallBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toObject()).toEqual({
+		data: fixture.data.data,
+		to: fixture.data.to,
+		value: fixture.data.value,
+		gasPrice: fixture.data.gasPrice,
+		gas: fixture.data.gas,
+		network: fixture.data.network,
+		nonce: fixture.data.nonce,
+		v: fixture.data.v,
+		r: fixture.data.r,
+		s: fixture.data.s,
+		senderPublicKey: fixture.data.senderPublicKey,
+		hash: fixture.data.hash,
+	});
+});
+
+it("should convert to json", async () => {
+	const transaction = await EvmCallBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toJson()).toEqual(
+		JSON.stringify({
+			gasPrice: fixture.data.gasPrice,
+			network: fixture.data.network,
+			hash: fixture.data.hash,
+			gas: fixture.data.gas,
+			nonce: fixture.data.nonce,
+			senderPublicKey: fixture.data.senderPublicKey,
+			to: fixture.data.to,
+			value: fixture.data.value,
+			data: fixture.data.data,
+			r: fixture.data.r,
+			s: fixture.data.s,
+			v: fixture.data.v,
+		}),
+	);
+});
+
+it("should convert to string", async () => {
+	const transaction = await EvmCallBuilder.new({ ...fixture.data }).sign(identityFixture.passphrase);
+
+	expect(transaction.toString()).toEqual(
+		JSON.stringify({
+			gasPrice: fixture.data.gasPrice,
+			network: fixture.data.network,
+			hash: fixture.data.hash,
+			gas: fixture.data.gas,
+			nonce: fixture.data.nonce,
+			senderPublicKey: fixture.data.senderPublicKey,
+			to: fixture.data.to,
+			value: fixture.data.value,
+			data: fixture.data.data,
+			r: fixture.data.r,
+			s: fixture.data.s,
+			v: fixture.data.v,
+		}),
+	);
+});