@arkecosystem/typescript-crypto 0.0.1

package/src/transactions/types/AbstractTransaction.ts

@@ -0,0 +1,118 @@
+import { AbiResult, ITransaction, TransactionData } from "@/types";
+
+import { Address } from "@/identities/Address";
+import { Constants } from "@/enums/Constants";
+import { ContractAbiType } from "@/enums/ContractAbiType";
+import { Network } from "@/configuration/Network";
+import { PrivateKey } from "@/identities/PrivateKey";
+import { PublicKey } from "@/identities/PublicKey";
+import { Serializer } from "@/transactions/Serializer";
+import { TransactionUtils } from "@/utils/TransactionUtils";
+
+export abstract class AbstractTransaction implements ITransaction {
+	public data: TransactionData;
+	public serialized: Buffer | undefined;
+
+	public constructor(data: TransactionData) {
+		this.data = { ...data };
+
+		this.refreshPayloadData();
+	}
+
+	public abstract getPayload(): string;
+
+	public refreshPayloadData(): this {
+		this.data.data = this.getPayload();
+
+		return this;
+	}
+
+	public getId(): string {
+		return TransactionUtils.getId(this.data);
+	}
+
+	public async sign(privateKey: PrivateKey): Promise<ITransaction> {
+		const hash = TransactionUtils.toBuffer(this.data, true).toString("binary");
+
+		const signature = await privateKey.sign(hash);
+
+		this.data["v"] = signature.v;
+		this.data["r"] = signature.r;
+		this.data["s"] = signature.s;
+
+		return this;
+	}
+
+	public recoverSender(): void {
+		const publicKey = this.recoverPublicKey();
+
+		this.data["senderPublicKey"] = publicKey.publicKey;
+		this.data["senderAddress"] = Address.fromPublicKey(publicKey.publicKey);
+	}
+
+	public verify(): boolean {
+		const recoveredPublicKey = this.recoverPublicKey();
+
+		const senderPublicKey = this.data.senderPublicKey;
+		if (!senderPublicKey) {
+			return false;
+		}
+
+		return recoveredPublicKey.publicKey === senderPublicKey;
+	}
+
+	public toArray(): TransactionData {
+		return [
+			"gasPrice",
+			"network",
+			"id",
+			"gasLimit",
+			"nonce",
+			"senderPublicKey",
+			"recipientAddress",
+			"value",
+			"data",
+			"r",
+			"s",
+			"v",
+		].reduce((acc: TransactionData, key) => {
+			if (this.data[key] !== undefined) {
+				acc[key] = this.data[key];
+			}
+
+			return acc;
+		}, {}) as TransactionData;
+	}
+
+	public toJson(): string {
+		return JSON.stringify(this.toArray());
+	}
+
+	public hash(skipSignature: boolean = false): string {
+		return TransactionUtils.toHash(this.data, skipSignature);
+	}
+
+	public serialize(skipSignature: boolean = false): Buffer {
+		return Serializer.new(this).serialize(skipSignature);
+	}
+
+	protected recoverPublicKey(): PublicKey {
+		if (!this.data.v || !this.data.r || !this.data.s) {
+			throw new Error("Transaction signature is missing");
+		}
+
+		return PublicKey.recover(
+			Buffer.from(this.hash(true), "hex"),
+			BigInt(`0x${this.data.r}`),
+			BigInt(`0x${this.data.s}`),
+			this.data.v - Constants.ETHEREUM_RECOVERY_ID_OFFSET,
+		);
+	}
+
+	protected decodePayload(
+		data: TransactionData,
+		type: ContractAbiType = ContractAbiType.CONSENSUS,
+	): AbiResult | null {
+		throw new Error("Method not implemented.");
+	}
+}

package/src/transactions/types/EvmCall.ts

@@ -0,0 +1,22 @@
+import { AbiResult, TransactionData } from "@/types";
+
+import { AbstractTransaction } from "./AbstractTransaction";
+import { ContractAbiType } from "@/enums/ContractAbiType";
+import { Deserializer } from "@/transactions/Deserializer";
+
+export class EvmCall extends AbstractTransaction {
+	getPayload(): string {
+		return this.data["data"] || "";
+	}
+
+	protected decodePayload(
+		data: TransactionData,
+		type: ContractAbiType = ContractAbiType.CONSENSUS,
+	): AbiResult | null {
+		if (!data["data"]) {
+			return null;
+		}
+
+		return Deserializer.decodePayload(data, type);
+	}
+}

package/src/transactions/types/Multipayment.ts

@@ -0,0 +1,51 @@
+import { AbiResult, TransactionData } from "@/types";
+
+import { AbiDecoder } from "@/utils/AbiDecoder";
+import { AbiEncoder } from "@/utils/AbiEncoder";
+import { AbiFunction } from "@/enums/AbiFunction";
+import { AbstractTransaction } from "./AbstractTransaction";
+import { ContractAbiType } from "@/enums/ContractAbiType";
+import { Deserializer } from "@/transactions/Deserializer";
+
+export class Multipayment extends AbstractTransaction {
+	public constructor(data: TransactionData) {
+		let payload;
+		if (!data["data"] || data["data"] === "") {
+			payload = null;
+		} else {
+			payload = new AbiDecoder(ContractAbiType.MULTIPAYMENT).decodeFunctionData(data["data"]);
+		}
+
+		if (payload && payload.args[0].length === payload.args[1].length) {
+			data["pay"] = payload.args;
+			data["value"] = payload.args[1].reduce((a: bigint, b: bigint) => a + b);
+		} else {
+			data["pay"] = [[], []];
+			data["value"] = "0";
+		}
+
+		super(data);
+	}
+
+	getPayload(): string {
+		if (!this.data["pay"]) {
+			return "";
+		}
+
+		return new AbiEncoder(ContractAbiType.MULTIPAYMENT).encodeFunctionCall(
+			AbiFunction.MULTIPAYMENT,
+			this.data["pay"] as any[],
+		);
+	}
+
+	protected decodePayload(
+		data: TransactionData,
+		type: ContractAbiType = ContractAbiType.CONSENSUS,
+	): AbiResult | null {
+		if (!data["data"]) {
+			return null;
+		}
+
+		return Deserializer.decodePayload(data, ContractAbiType.MULTIPAYMENT);
+	}
+}

package/src/transactions/types/Transfer.ts

@@ -0,0 +1,22 @@
+import { AbiResult, TransactionData } from "@/types";
+
+import { AbstractTransaction } from "./AbstractTransaction";
+import { ContractAbiType } from "@/enums/ContractAbiType";
+import { Deserializer } from "@/transactions/Deserializer";
+
+export class Transfer extends AbstractTransaction {
+	getPayload(): string {
+		return "";
+	}
+
+	protected decodePayload(
+		data: TransactionData,
+		type: ContractAbiType = ContractAbiType.CONSENSUS,
+	): AbiResult | null {
+		if (!data["data"]) {
+			return null;
+		}
+
+		return Deserializer.decodePayload(data, type);
+	}
+}

package/src/transactions/types/Unvote.ts

@@ -0,0 +1,24 @@
+import { AbiResult, TransactionData } from "@/types";
+
+import { AbiEncoder } from "@/utils/AbiEncoder";
+import { AbiFunction } from "@/enums/AbiFunction";
+import { AbstractTransaction } from "./AbstractTransaction";
+import { ContractAbiType } from "@/enums/ContractAbiType";
+import { Deserializer } from "@/transactions/Deserializer";
+
+export class Unvote extends AbstractTransaction {
+	getPayload(): string {
+		return new AbiEncoder().encodeFunctionCall(AbiFunction.UNVOTE, []);
+	}
+
+	protected decodePayload(
+		data: TransactionData,
+		type: ContractAbiType = ContractAbiType.CONSENSUS,
+	): AbiResult | null {
+		if (!data["data"]) {
+			return null;
+		}
+
+		return Deserializer.decodePayload(data, type);
+	}
+}

package/src/transactions/types/UsernameRegistration.ts

@@ -0,0 +1,44 @@
+import { AbiResult, TransactionData } from "@/types";
+
+import { AbiDecoder } from "@/utils/AbiDecoder";
+import { AbiEncoder } from "@/utils/AbiEncoder";
+import { AbiFunction } from "@/enums/AbiFunction";
+import { AbstractTransaction } from "./AbstractTransaction";
+import { ContractAbiType } from "@/enums/ContractAbiType";
+import { Deserializer } from "@/transactions/Deserializer";
+
+export class UsernameRegistration extends AbstractTransaction {
+	public constructor(data: TransactionData) {
+		let payload;
+		if (!data["data"] || data["data"] === "") {
+			payload = null;
+		} else {
+			payload = new AbiDecoder(ContractAbiType.USERNAMES).decodeFunctionData(data["data"]);
+		}
+
+		data["username"] = payload ? payload.args[0] : null;
+
+		super(data);
+	}
+
+	getPayload(): string {
+		if (!this.data["username"]) {
+			return "";
+		}
+
+		return new AbiEncoder(ContractAbiType.USERNAMES).encodeFunctionCall(AbiFunction.USERNAME_REGISTRATION, [
+			this.data["username"],
+		]);
+	}
+
+	protected decodePayload(
+		data: TransactionData,
+		type: ContractAbiType = ContractAbiType.CONSENSUS,
+	): AbiResult | null {
+		if (!data["data"]) {
+			return null;
+		}
+
+		return Deserializer.decodePayload(data, ContractAbiType.USERNAMES);
+	}
+}

package/src/transactions/types/UsernameResignation.ts

@@ -0,0 +1,24 @@
+import { AbiResult, TransactionData } from "@/types";
+
+import { AbiEncoder } from "@/utils/AbiEncoder";
+import { AbiFunction } from "@/enums/AbiFunction";
+import { AbstractTransaction } from "./AbstractTransaction";
+import { ContractAbiType } from "@/enums/ContractAbiType";
+import { Deserializer } from "@/transactions/Deserializer";
+
+export class UsernameResignation extends AbstractTransaction {
+	getPayload(): string {
+		return new AbiEncoder(ContractAbiType.USERNAMES).encodeFunctionCall(AbiFunction.USERNAME_RESIGNATION, []);
+	}
+
+	protected decodePayload(
+		data: TransactionData,
+		type: ContractAbiType = ContractAbiType.CONSENSUS,
+	): AbiResult | null {
+		if (!data["data"]) {
+			return null;
+		}
+
+		return Deserializer.decodePayload(data, ContractAbiType.USERNAMES);
+	}
+}

package/src/transactions/types/ValidatorRegistration.ts

@@ -0,0 +1,44 @@
+import { AbiResult, TransactionData } from "@/types";
+
+import { AbiDecoder } from "@/utils/AbiDecoder";
+import { AbiEncoder } from "@/utils/AbiEncoder";
+import { AbiFunction } from "@/enums/AbiFunction";
+import { AbstractTransaction } from "./AbstractTransaction";
+import { ContractAbiType } from "@/enums/ContractAbiType";
+import { Deserializer } from "@/transactions/Deserializer";
+
+export class ValidatorRegistration extends AbstractTransaction {
+	public constructor(data: TransactionData) {
+		let payload;
+		if (!data["data"] || data["data"] === "") {
+			payload = null;
+		} else {
+			payload = new AbiDecoder().decodeFunctionData(data["data"]);
+		}
+
+		data["validatorPublicKey"] = payload ? payload.args[0] : null;
+
+		super(data);
+	}
+
+	getPayload(): string {
+		if (!this.data["validatorPublicKey"]) {
+			return "";
+		}
+
+		return new AbiEncoder().encodeFunctionCall(AbiFunction.VALIDATOR_REGISTRATION, [
+			this.data["validatorPublicKey"],
+		]);
+	}
+
+	protected decodePayload(
+		data: TransactionData,
+		type: ContractAbiType = ContractAbiType.CONSENSUS,
+	): AbiResult | null {
+		if (!data["data"]) {
+			return null;
+		}
+
+		return Deserializer.decodePayload(data, type);
+	}
+}

package/src/transactions/types/ValidatorResignation.ts

@@ -0,0 +1,24 @@
+import { AbiResult, TransactionData } from "@/types";
+
+import { AbiEncoder } from "@/utils/AbiEncoder";
+import { AbiFunction } from "@/enums/AbiFunction";
+import { AbstractTransaction } from "./AbstractTransaction";
+import { ContractAbiType } from "@/enums/ContractAbiType";
+import { Deserializer } from "@/transactions/Deserializer";
+
+export class ValidatorResignation extends AbstractTransaction {
+	getPayload(): string {
+		return new AbiEncoder().encodeFunctionCall(AbiFunction.VALIDATOR_RESIGNATION, []);
+	}
+
+	protected decodePayload(
+		data: TransactionData,
+		type: ContractAbiType = ContractAbiType.CONSENSUS,
+	): AbiResult | null {
+		if (!data["data"]) {
+			return null;
+		}
+
+		return Deserializer.decodePayload(data, type);
+	}
+}

package/src/transactions/types/Vote.ts

@@ -0,0 +1,42 @@
+import { AbiResult, TransactionData } from "@/types";
+
+import { AbiDecoder } from "@/utils/AbiDecoder";
+import { AbiEncoder } from "@/utils/AbiEncoder";
+import { AbiFunction } from "@/enums/AbiFunction";
+import { AbstractTransaction } from "./AbstractTransaction";
+import { ContractAbiType } from "@/enums/ContractAbiType";
+import { Deserializer } from "@/transactions/Deserializer";
+
+export class Vote extends AbstractTransaction {
+	public constructor(data: TransactionData) {
+		let payload;
+		if (!data["data"] || data["data"] === "") {
+			payload = null;
+		} else {
+			payload = new AbiDecoder().decodeFunctionData(data["data"]);
+		}
+
+		data["vote"] = payload ? payload.args[0] : null;
+
+		super(data);
+	}
+
+	getPayload(): string {
+		if (!this.data["vote"]) {
+			return "";
+		}
+
+		return new AbiEncoder().encodeFunctionCall(AbiFunction.VOTE, [this.data["vote"]]);
+	}
+
+	protected decodePayload(
+		data: TransactionData,
+		type: ContractAbiType = ContractAbiType.CONSENSUS,
+	): AbiResult | null {
+		if (!data["data"]) {
+			return null;
+		}
+
+		return Deserializer.decodePayload(data, type);
+	}
+}

package/src/transactions/types/index.ts

@@ -0,0 +1,10 @@
+export * from "./AbstractTransaction";
+export * from "./EvmCall";
+export * from "./Multipayment";
+export * from "./Transfer";
+export * from "./Unvote";
+export * from "./ValidatorRegistration";
+export * from "./ValidatorResignation";
+export * from "./UsernameRegistration";
+export * from "./UsernameResignation";
+export * from "./Vote";

package/src/types.ts

@@ -0,0 +1,86 @@
+import { Result } from "ethers";
+
+export type TransactionData = {
+	gasPrice?: string | null;
+	network?: number | string | null;
+	id?: string | null;
+	gasLimit?: string | null;
+	nonce?: number | string | null;
+	senderPublicKey?: string | null;
+	recipientAddress?: string | null;
+	value?: string | null;
+	data?: string | null;
+	r?: string;
+	s?: string;
+	v?: number;
+
+	[key: string]: number | string | undefined | null | Array<any> | string;
+};
+
+export type AbiResult = {
+	functionName: string;
+	args: Result;
+};
+
+export type SignedMessage = {
+	publicKey: string;
+	signature: string;
+	message: string;
+};
+
+export interface ITransaction {
+	data: TransactionData;
+	serialized: Buffer | undefined;
+
+	getPayload(): string;
+	refreshPayloadData(): this;
+	getId(): string;
+	sign(privateKey: any): Promise<ITransaction>;
+	recoverSender(): void;
+
+	verify(): boolean;
+	toArray(): TransactionData;
+	toJson(): string;
+	hash(skipSignature?: boolean): string;
+	serialize(skipSignature?: boolean): Buffer;
+}
+
+export interface ITransactionBuilder<T extends ITransactionBuilder<T>> {
+	transaction: ITransaction;
+
+	gasLimit(gasLimit: string): T;
+	gasPrice(gasPrice: string): T;
+	recipientAddress(recipientAddress: string): T;
+	nonce(nonce: string): T;
+	network(network: number): T;
+	sign(passphrase: string): Promise<T>;
+	verify(): boolean;
+	toArray(): TransactionData;
+	toJson(): string;
+}
+
+export interface ITransferBuilder extends ITransactionBuilder<ITransferBuilder> {
+	value(value: string): ITransferBuilder;
+}
+
+export interface IVoteBuilder extends ITransactionBuilder<IVoteBuilder> {
+	vote(vote: string): IVoteBuilder;
+}
+
+export interface IValidatorRegistrationBuilder extends ITransactionBuilder<IValidatorRegistrationBuilder> {
+	validatorPublicKey(validatorPublicKey: string): IValidatorRegistrationBuilder;
+}
+
+export interface IUsernameRegistrationBuilder extends ITransactionBuilder<IUsernameRegistrationBuilder> {
+	username(username: string): IUsernameRegistrationBuilder;
+}
+
+export interface IEvmCallBuilder extends ITransactionBuilder<IEvmCallBuilder> {
+	payload(payload: string): IEvmCallBuilder;
+}
+
+export interface IMultipaymentBuilder extends ITransactionBuilder<IMultipaymentBuilder> {
+	pay(address: string, amount: string): IMultipaymentBuilder;
+}
+
+export interface IBasicTransactionBuilder extends ITransactionBuilder<IBasicTransactionBuilder> {}

package/src/utils/Abi/ArgumentDecoder.ts

@@ -0,0 +1,29 @@
+import { AbiCoder } from "ethers";
+
+export class ArgumentDecoder {
+	private bytes: Buffer;
+
+	constructor(bytes: string) {
+		this.bytes = Buffer.from(bytes, 'hex');
+	}
+
+	decodeString(): string {
+		return new AbiCoder().decode(['string'], this.bytes)[0].toString();
+	}
+
+	decodeAddress(): string {
+		return new AbiCoder().decode(['address'], this.bytes).toString();
+	}
+
+	decodeUnsignedInt(): string {
+		return new AbiCoder().decode(['uint'], this.bytes)[0].toString();
+	}
+
+	decodeSignedInt(): string {
+		return new AbiCoder().decode(['int'], this.bytes)[0].toString();
+	}
+
+	decodeBool(): boolean {
+		return new AbiCoder().decode(['bool'], this.bytes)[0] === true;
+	}
+}