@arkecosystem/typescript-crypto 0.0.1

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from "./configuration";
+export * from "./enums";
+export * from "./exceptions";
+export * from "./identities";
+export * from "./networks";
+export * from "./transactions";
+export * from "./utils";

package/src/networks/AbstractNetwork.ts

@@ -0,0 +1,7 @@
+export abstract class AbstractNetwork {
+    abstract chainId(): number;
+
+    abstract epoch(): string;
+
+    abstract getWif(): string;
+}

package/src/networks/Mainnet.ts

@@ -0,0 +1,15 @@
+import { AbstractNetwork } from "./AbstractNetwork";
+
+export class Mainnet extends AbstractNetwork {
+	public chainId(): number {
+		return 10000;
+	}
+
+	public epoch(): string {
+        return "2017-03-21T13:00:00.000Z";
+	}
+
+	public getWif(): string {
+        return "ba";
+	}
+}

package/src/networks/Testnet.ts

@@ -0,0 +1,15 @@
+import { AbstractNetwork } from "./AbstractNetwork";
+
+export class Testnet extends AbstractNetwork {
+	public chainId(): number {
+		return 10000;
+	}
+
+	public epoch(): string {
+		return "2017-03-21T13:00:00.000Z";
+	}
+
+	public getWif(): string {
+		return "ba";
+	}
+}

package/src/networks/index.ts

@@ -0,0 +1,3 @@
+export * from "./AbstractNetwork";
+export * from "./Mainnet";
+export * from "./Testnet";

package/src/transactions/Deserializer.ts

@@ -0,0 +1,140 @@
+import { AbiResult, ITransaction, TransactionData } from "@/types";
+
+import BigNumber from "bignumber.js";
+import { Constants } from "@/enums/Constants";
+import { ContractAbiType } from "@/enums/ContractAbiType";
+import { Transfer } from "./types/Transfer";
+import { decodeRlp } from "ethers";
+import { EvmCall, Multipayment, Unvote, UsernameRegistration, UsernameResignation, ValidatorRegistration, ValidatorResignation, Vote } from "./types";
+import { AbiFunction } from "@/enums";
+import { AbiDecoder } from "@/utils";
+
+export class Deserializer {
+	SIGNATURE_SIZE = 64;
+	RECOVERY_SIZE = 1;
+
+	encoded_rlp: string;
+	serialized: string;
+
+	constructor(serialized: string) {
+		this.serialized = serialized;
+		this.encoded_rlp = "0x" + serialized.substring(2);
+	}
+
+	static new(serialized: string): Deserializer {
+		return new Deserializer(serialized);
+	}
+
+	deserialize(): ITransaction {
+		const decodedRlp = decodeRlp(this.encoded_rlp);
+
+		const data: TransactionData = {
+			network: Number(decodedRlp[0]),
+			nonce: Deserializer.parseNumber(decodedRlp[1] as string),
+			gasPrice: Deserializer.parseNumber(decodedRlp[3] as string).toString(),
+			gasLimit: Deserializer.parseNumber(decodedRlp[4] as string).toString(),
+			recipientAddress: Deserializer.parseAddress(decodedRlp[5] as string),
+			value: Deserializer.parseBigNumber(decodedRlp[6] as string),
+			data: Deserializer.parseHex(decodedRlp[7] as string),
+		};
+
+		if (decodedRlp.length === 12) {
+			data["v"] = Deserializer.parseNumber(decodedRlp[9] as string) + Constants.ETHEREUM_RECOVERY_ID_OFFSET;
+			data["r"] = Deserializer.parseHex(decodedRlp[10] as string);
+			data["s"] = Deserializer.parseHex(decodedRlp[11] as string);
+		}
+
+		const transaction = this.guessTransactionFromData(data);
+
+		transaction.data = data;
+		transaction.recoverSender();
+
+		transaction.data["id"] = transaction.getId();
+
+		return transaction;
+	}
+
+	guessTransactionFromData(data: TransactionData): ITransaction {
+		const multipaymentPayloadData = Deserializer.decodePayload(data, ContractAbiType.MULTIPAYMENT);
+		if (multipaymentPayloadData !== null) {
+			const functionName = multipaymentPayloadData.functionName;
+			if (functionName == AbiFunction.MULTIPAYMENT) {
+				return new Multipayment(data);
+			}
+		}
+
+		if (data.value !== "0") {
+			return new Transfer(data);
+		}
+
+		const consensusPayloadData = Deserializer.decodePayload(data);
+		if (consensusPayloadData !== null) {
+			const functionName = consensusPayloadData.functionName;
+			if (functionName == AbiFunction.VOTE) {
+				return new Vote(data);
+			}
+
+			if (functionName == AbiFunction.UNVOTE) {
+				return new Unvote(data);
+			}
+
+			if (functionName == AbiFunction.VALIDATOR_REGISTRATION) {
+				return new ValidatorRegistration(data);
+			}
+
+			if (functionName == AbiFunction.VALIDATOR_RESIGNATION) {
+				return new ValidatorResignation(data);
+			}
+		}
+
+		const usernamePayloadData = Deserializer.decodePayload(data, ContractAbiType.USERNAMES);
+		if (usernamePayloadData !== null) {
+			const functionName = usernamePayloadData.functionName;
+			if (functionName == AbiFunction.USERNAME_REGISTRATION) {
+				return new UsernameRegistration(data);
+			}
+
+			if (functionName == AbiFunction.USERNAME_RESIGNATION) {
+				return new UsernameResignation(data);
+			}
+		}
+
+		return new EvmCall(data)
+	}
+
+	static decodePayload(
+		data: TransactionData,
+		abiType: ContractAbiType = ContractAbiType.CONSENSUS,
+	): AbiResult | null {
+		const payload = data.data;
+
+		if (! payload) {
+			return null;
+		}
+
+		const decoder = new AbiDecoder(abiType);
+		try {
+			return decoder.decodeFunctionData(payload);
+		} catch (e) {
+			//
+		}
+
+		return null;
+	}
+
+	static parseNumber(value: string): number {
+		return value === "0x" ? 0 : Number(value);
+	}
+
+	static parseBigNumber(value: string): string {
+		return (value === "0x" ? new BigNumber(0) : new BigNumber(value)).toString(10);
+	}
+
+	static parseAddress(value: string): string | undefined {
+		return value === "0x" ? undefined : value;
+	}
+
+	static parseHex(value: string): string {
+		return value.replace(/^0x/, "");
+	}
+}

package/src/transactions/Serializer.ts

@@ -0,0 +1,24 @@
+import { ITransaction } from "@/types";
+import { TransactionUtils } from "@/utils/TransactionUtils";
+
+export class Serializer {
+	public transaction: ITransaction;
+
+	constructor(transaction: ITransaction) {
+		this.transaction = transaction;
+	}
+
+	static new(transaction: ITransaction): Serializer {
+		return new this(transaction);
+	}
+
+	static getBytes(transaction: ITransaction, skipSignature: boolean = false): Buffer {
+		return transaction.serialize(skipSignature);
+	}
+
+	serialize(skipSignature: boolean = false): Buffer {
+		this.transaction.serialized = TransactionUtils.toBuffer(this.transaction.data, skipSignature);
+
+		return this.transaction.serialized;
+	}
+}

package/src/transactions/builders/AbstractTransactionBuilder.ts

@@ -0,0 +1,81 @@
+import { ITransaction, ITransactionBuilder, TransactionData } from "@/types";
+
+import { Network } from "@/configuration/Network";
+import { PrivateKey } from "@/identities/PrivateKey";
+import { PublicKey } from "@/identities/PublicKey";
+
+export abstract class AbstractTransactionBuilder<T extends ITransactionBuilder<T>> implements ITransactionBuilder<T> {
+	public transaction: ITransaction;
+
+	constructor(data?: Record<string, any>) {
+		this.transaction = this.getTransactionInstance(
+			data ?? {
+				value: "0",
+				senderPublicKey: "",
+				gasPrice: "5",
+				nonce: "1",
+				network: Network.get().chainId(),
+				gasLimit: 1_000_000,
+				data: "",
+			},
+		);
+	}
+
+	public gasLimit(gasLimit: string): T {
+		this.transaction.data.gasLimit = gasLimit;
+
+		return this as unknown as T;
+	}
+
+	public recipientAddress(recipientAddress: string): T {
+		this.transaction.data.recipientAddress = recipientAddress;
+
+		return this as unknown as T;
+	}
+
+	public gasPrice(gasPrice: string): T {
+		this.transaction.data.gasPrice = gasPrice;
+
+		return this as unknown as T;
+	}
+
+	public nonce(nonce: string): T {
+		this.transaction.data.nonce = nonce;
+
+		return this as unknown as T;
+	}
+
+	public network(network: number): T {
+		this.transaction.data.network = network;
+
+		return this as unknown as T;
+	}
+
+	public async sign(passphrase: string): Promise<T> {
+		this.transaction.data.senderPublicKey = PublicKey.fromPassphrase(passphrase).publicKey;
+
+		this.transaction = await this.transaction.sign(PrivateKey.fromPassphrase(passphrase));
+
+		this.transaction.data.id = this.transaction.getId();
+
+		return this as unknown as T;
+	}
+
+	public verify(): boolean {
+		return this.transaction.verify();
+	}
+
+	public toArray(): TransactionData {
+		return this.transaction.toArray();
+	}
+
+	public toJson(): string {
+		return this.transaction.toJson();
+	}
+
+	public toString(): string {
+		return this.toJson();
+	}
+
+	protected abstract getTransactionInstance(data?: Record<string, any>): ITransaction;
+}

package/src/transactions/builders/EvmCallBuilder.ts

@@ -0,0 +1,24 @@
+import { IEvmCallBuilder, ITransaction, TransactionData } from "@/types";
+
+import { AbstractTransactionBuilder } from "./AbstractTransactionBuilder";
+import { EvmCall } from "@/transactions/types/EvmCall";
+import { Helpers } from "@/utils/Helpers";
+
+export class EvmCallBuilder extends AbstractTransactionBuilder<IEvmCallBuilder> implements IEvmCallBuilder {
+	public constructor(data?: Record<string, any>) {
+		super(data);
+	}
+
+	public static new(data?: Record<string, any>): IEvmCallBuilder {
+		return new this(data);
+	}
+
+	public payload(payload: string): IEvmCallBuilder {
+		this.transaction.data["data"] = Helpers.removeLeadingHexZero(payload);
+		return this;
+	}
+
+	protected getTransactionInstance(data?: Record<string, any>): ITransaction {
+		return new EvmCall(data as TransactionData);
+	}
+}

package/src/transactions/builders/MultipaymentBuilder.ts

@@ -0,0 +1,37 @@
+import { IMultipaymentBuilder, ITransaction, TransactionData } from "@/types";
+
+import { AbstractTransactionBuilder } from "./AbstractTransactionBuilder";
+import { ContractAddresses } from "@/enums/ContractAddresses";
+import { Multipayment } from "@/transactions/types/Multipayment";
+
+export class MultipaymentBuilder
+	extends AbstractTransactionBuilder<IMultipaymentBuilder>
+	implements IMultipaymentBuilder
+{
+	public constructor(data?: Record<string, any>) {
+		super(data);
+
+		this.recipientAddress(ContractAddresses.MULTIPAYMENT);
+	}
+
+	public static new(data?: Record<string, any>): IMultipaymentBuilder {
+		return new this(data);
+	}
+
+	public pay(address: string, amount: string): IMultipaymentBuilder {
+		let payload: [string[], string[]] = this.transaction.data["pay"] as [string[], string[]];
+		payload[0].push(address);
+		payload[1].push(amount);
+		this.transaction.data.pay = payload;
+
+		this.transaction.data.value = (BigInt(this.transaction.data.value ?? 0) + BigInt(amount)).toString();
+
+		this.transaction.refreshPayloadData();
+
+		return this;
+	}
+
+	protected getTransactionInstance(data?: Record<string, any>): ITransaction {
+		return new Multipayment(data as TransactionData);
+	}
+}

package/src/transactions/builders/TransferBuilder.ts

@@ -0,0 +1,22 @@
+import { ITransaction, ITransferBuilder, TransactionData } from "@/types";
+
+import { AbstractTransactionBuilder } from "./AbstractTransactionBuilder";
+import { Transfer } from "@/transactions/types/Transfer";
+
+export class TransferBuilder extends AbstractTransactionBuilder<ITransferBuilder> implements ITransferBuilder {
+	public static new(data?: Record<string, any>): ITransferBuilder {
+		return new this(data);
+	}
+
+	public value(value: string): ITransferBuilder {
+		this.transaction.data.value = value;
+
+		this.transaction.refreshPayloadData();
+
+		return this;
+	}
+
+	protected getTransactionInstance(data?: Record<string, any>): ITransaction {
+		return new Transfer(data as TransactionData);
+	}
+}

package/src/transactions/builders/UnvoteBuilder.ts

@@ -0,0 +1,21 @@
+import { IBasicTransactionBuilder, ITransaction, TransactionData } from "@/types";
+
+import { AbstractTransactionBuilder } from "./AbstractTransactionBuilder";
+import { ContractAddresses } from "@/enums/ContractAddresses";
+import { Unvote } from "@/transactions/types/Unvote";
+
+export class UnvoteBuilder extends AbstractTransactionBuilder<IBasicTransactionBuilder> {
+	public constructor(data?: Record<string, any>) {
+		super(data);
+
+		this.recipientAddress(ContractAddresses.CONSENSUS);
+	}
+
+	public static new(data?: Record<string, any>): IBasicTransactionBuilder {
+		return new this(data);
+	}
+
+	protected getTransactionInstance(data?: Record<string, any>): ITransaction {
+		return new Unvote(data as TransactionData);
+	}
+}

package/src/transactions/builders/UsernameRegistrationBuilder.ts

@@ -0,0 +1,35 @@
+import { ITransaction, IUsernameRegistrationBuilder, TransactionData } from "@/types";
+
+import { AbstractTransactionBuilder } from "./AbstractTransactionBuilder";
+import { ContractAddresses } from "@/enums/ContractAddresses";
+import { Helpers } from "@/utils/Helpers";
+import { UsernameRegistration } from "@/transactions/types/UsernameRegistration";
+
+export class UsernameRegistrationBuilder
+	extends AbstractTransactionBuilder<IUsernameRegistrationBuilder>
+	implements IUsernameRegistrationBuilder
+{
+	public constructor(data?: Record<string, any>) {
+		super(data);
+
+		this.recipientAddress(ContractAddresses.USERNAMES);
+	}
+
+	public static new(data?: Record<string, any>): IUsernameRegistrationBuilder {
+		return new this(data);
+	}
+
+	public username(username: string): IUsernameRegistrationBuilder {
+		Helpers.isValidUsername(username);
+
+		this.transaction.data.username = username;
+
+		this.transaction.refreshPayloadData();
+
+		return this;
+	}
+
+	protected getTransactionInstance(data?: Record<string, any>): ITransaction {
+		return new UsernameRegistration(data as TransactionData);
+	}
+}

package/src/transactions/builders/UsernameResignationBuilder.ts

@@ -0,0 +1,21 @@
+import { IBasicTransactionBuilder, ITransaction, TransactionData } from "@/types";
+
+import { AbstractTransactionBuilder } from "./AbstractTransactionBuilder";
+import { ContractAddresses } from "@/enums/ContractAddresses";
+import { UsernameResignation } from "@/transactions/types/UsernameResignation";
+
+export class UsernameResignationBuilder extends AbstractTransactionBuilder<IBasicTransactionBuilder> {
+	public constructor(data?: Record<string, any>) {
+		super(data);
+
+		this.recipientAddress(ContractAddresses.USERNAMES);
+	}
+
+	public static new(data?: Record<string, any>): IBasicTransactionBuilder {
+		return new this(data);
+	}
+
+	protected getTransactionInstance(data?: Record<string, any>): ITransaction {
+		return new UsernameResignation(data as TransactionData);
+	}
+}

package/src/transactions/builders/ValidatorRegistrationBuilder.ts

@@ -0,0 +1,32 @@
+import { ITransaction, IValidatorRegistrationBuilder, TransactionData } from "@/types";
+
+import { AbstractTransactionBuilder } from "./AbstractTransactionBuilder";
+import { ContractAddresses } from "@/enums/ContractAddresses";
+import { ValidatorRegistration } from "@/transactions/types/ValidatorRegistration";
+
+export class ValidatorRegistrationBuilder
+	extends AbstractTransactionBuilder<IValidatorRegistrationBuilder>
+	implements IValidatorRegistrationBuilder
+{
+	public constructor(data?: Record<string, any>) {
+		super(data);
+
+		this.recipientAddress(ContractAddresses.CONSENSUS);
+	}
+
+	public static new(data?: Record<string, any>): IValidatorRegistrationBuilder {
+		return new this(data);
+	}
+
+	public validatorPublicKey(validatorPublicKey: string): IValidatorRegistrationBuilder {
+		this.transaction.data.validatorPublicKey = validatorPublicKey;
+
+		this.transaction.refreshPayloadData();
+
+		return this;
+	}
+
+	protected getTransactionInstance(data?: Record<string, any>): ITransaction {
+		return new ValidatorRegistration(data as TransactionData);
+	}
+}

package/src/transactions/builders/ValidatorResignationBuilder.ts

@@ -0,0 +1,21 @@
+import { IBasicTransactionBuilder, ITransaction, TransactionData } from "@/types";
+
+import { AbstractTransactionBuilder } from "./AbstractTransactionBuilder";
+import { ContractAddresses } from "@/enums/ContractAddresses";
+import { ValidatorResignation } from "@/transactions/types/ValidatorResignation";
+
+export class ValidatorResignationBuilder extends AbstractTransactionBuilder<IBasicTransactionBuilder> {
+	public constructor(data?: Record<string, any>) {
+		super(data);
+
+		this.recipientAddress(ContractAddresses.CONSENSUS);
+	}
+
+	public static new(data?: Record<string, any>): IBasicTransactionBuilder {
+		return new this(data);
+	}
+
+	protected getTransactionInstance(data?: Record<string, any>): ITransaction {
+		return new ValidatorResignation(data as TransactionData);
+	}
+}

package/src/transactions/builders/VoteBuilder.ts

@@ -0,0 +1,29 @@
+import { ITransaction, IVoteBuilder, TransactionData } from "@/types";
+
+import { AbstractTransactionBuilder } from "./AbstractTransactionBuilder";
+import { ContractAddresses } from "@/enums/ContractAddresses";
+import { Vote } from "@/transactions/types/Vote";
+
+export class VoteBuilder extends AbstractTransactionBuilder<IVoteBuilder> implements IVoteBuilder {
+	public constructor(data?: Record<string, any>) {
+		super(data);
+
+		this.recipientAddress(ContractAddresses.CONSENSUS);
+	}
+
+	public static new(data?: Record<string, any>): IVoteBuilder {
+		return new this(data);
+	}
+
+	public vote(vote: string): IVoteBuilder {
+		this.transaction.data.vote = vote;
+
+		this.transaction.refreshPayloadData();
+
+		return this;
+	}
+
+	protected getTransactionInstance(data?: Record<string, any>): ITransaction {
+		return new Vote(data as TransactionData);
+	}
+}

package/src/transactions/builders/index.ts

@@ -0,0 +1,10 @@
+export * from "./AbstractTransactionBuilder";
+export * from "./EvmCallBuilder";
+export * from "./MultipaymentBuilder";
+export * from "./TransferBuilder";
+export * from "./UnvoteBuilder";
+export * from "./ValidatorRegistrationBuilder";
+export * from "./ValidatorResignationBuilder";
+export * from "./UsernameRegistrationBuilder";
+export * from "./UsernameResignationBuilder";
+export * from "./VoteBuilder";

package/src/transactions/index.ts

@@ -0,0 +1,4 @@
+export * from "./builders";
+export * from "./types";
+export * from "./Deserializer";
+export * from "./Serializer";