Implemented the Message and MessageComputer classes

src/constants.ts

@@ -14,3 +14,5 @@ export const CONTRACT_DEPLOY_ADDRESS = "erd1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq
 export const DELEGATION_MANAGER_SC_ADDRESS = "erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqylllslmq6y6";
 export const DEFAULT_HRP = "erd";
 export const ESDT_CONTRACT_ADDRESS = "erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqzllls8a5w6u";
+export const DEFAULT_MESSAGE_VERSION = 1;
+export const MESSAGE_PREFIX = "\x17Elrond Signed Message:\n";

src/interface.ts

@@ -26,16 +26,45 @@ export interface IPlainTransactionObject {
     guardianSignature?: string;
 }
 
-export interface ISignature { hex(): string; }
-export interface IAddress { bech32(): string; }
-export interface ITransactionValue { toString(): string; }
-export interface IAccountBalance { toString(): string; }
-export interface INonce { valueOf(): number; }
-export interface IChainID { valueOf(): string; }
-export interface IGasLimit { valueOf(): number; }
-export interface IGasPrice { valueOf(): number; }
-export interface ITransactionVersion { valueOf(): number; }
-export interface ITransactionOptions { valueOf(): number; }
+export interface ISignature {
+    hex(): string;
+}
+
+export interface IAddress {
+    bech32(): string;
+}
+
+export interface ITransactionValue {
+    toString(): string;
+}
+
+export interface IAccountBalance {
+    toString(): string;
+}
+
+export interface INonce {
+    valueOf(): number;
+}
+
+export interface IChainID {
+    valueOf(): string;
+}
+
+export interface IGasLimit {
+    valueOf(): number;
+}
+
+export interface IGasPrice {
+    valueOf(): number;
+}
+
+export interface ITransactionVersion {
+    valueOf(): number;
+}
+
+export interface ITransactionOptions {
+    valueOf(): number;
+}
 
 export interface ITransactionPayload {
     length(): number;
@@ -72,4 +101,4 @@ export interface ITransactionNext {
     guardian: string;
     signature: Uint8Array;
     guardianSignature: Uint8Array;
-  }
+}

src/message.spec.ts

@@ -0,0 +1,87 @@
+import { assert } from "chai";
+import { Message, MessageComputer } from "./message";
+import { loadTestWallets, TestWallet } from "./testutils";
+import { UserVerifier } from "@multiversx/sdk-wallet";
+import { DEFAULT_MESSAGE_VERSION } from "./constants";
+
+describe("test message", () => {
+    let alice: TestWallet;
+    const messageComputer = new MessageComputer();
+
+    before(async function () {
+        ({ alice } = await loadTestWallets());
+    });
+
+    it("should test message compute bytes for signing", async () => {
+        const data = Buffer.from("test message");
+
+        const message = new Message({
+            data: data,
+        });
+
+        const serialized = messageComputer.computeBytesForSigning(message);
+
+        assert.equal(
+            Buffer.from(serialized).toString("hex"),
+            "2162d6271208429e6d3e664139e98ba7c5f1870906fb113e8903b1d3f531004d",
+        );
+    });
+
+    it("should create, sign, pack, unpack and verify message", async () => {
+        const data = Buffer.from("test");
+
+        const message = new Message({
+            data: data,
+            address: alice.getAddress(),
+        });
+
+        message.signature = await alice.signer.sign(Buffer.from(messageComputer.computeBytesForSigning(message)));
+
+        assert.equal(
+            Buffer.from(message.signature).toString("hex"),
+            "7aff43cd6e3d880a65033bf0a1b16274854fd7dfa9fe5faa7fa9a665ee851afd4c449310f5f1697d348e42d1819eaef69080e33e7652d7393521ed50d7427a0e",
+        );
+
+        const packedMessage = messageComputer.packMessage(message);
+        assert.deepEqual(packedMessage, {
+            address: "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th",
+            message: "74657374",
+            signature:
+                "7aff43cd6e3d880a65033bf0a1b16274854fd7dfa9fe5faa7fa9a665ee851afd4c449310f5f1697d348e42d1819eaef69080e33e7652d7393521ed50d7427a0e",
+            version: 1,
+        });
+
+        const unpackedMessage = messageComputer.unpackMessage(packedMessage);
+        assert.deepEqual(unpackedMessage.address, alice.getAddress());
+        assert.deepEqual(unpackedMessage.data, message.data);
+        assert.deepEqual(unpackedMessage.signature, message.signature);
+        assert.deepEqual(unpackedMessage.version, message.version);
+
+        const verifier = UserVerifier.fromAddress(alice.getAddress());
+        const isValid = verifier.verify(
+            Buffer.from(messageComputer.computeBytesForVerifying(unpackedMessage)),
+            Buffer.from(unpackedMessage.signature!),
+        );
+        assert.equal(isValid, true);
+    });
+
+    it("should unpack legacy message", async () => {
+        const legacyMessage = {
+            address: "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th",
+            message: "0x7468697320697320612074657374206d657373616765",
+            signature:
+                "0xb16847437049986f936dd4a0917c869730cbf29e40a0c0821ca70db33f44758c3d41bcbea446dee70dea13d50942343bb78e74979dc434bbb2b901e0f4fd1809",
+            version: 1,
+            signer: "ErdJS",
+        };
+
+        const message = messageComputer.unpackMessage(legacyMessage);
+        assert.deepEqual(message.address, alice.getAddress());
+        assert.deepEqual(Buffer.from(message.data).toString(), "this is a test message");
+        assert.deepEqual(
+            Buffer.from(message.signature!).toString("hex"),
+            "b16847437049986f936dd4a0917c869730cbf29e40a0c0821ca70db33f44758c3d41bcbea446dee70dea13d50942343bb78e74979dc434bbb2b901e0f4fd1809",
+        );
+        assert.deepEqual(message.version, DEFAULT_MESSAGE_VERSION);
+    });
+});

src/message.ts

@@ -0,0 +1,90 @@
+import { IAddress } from "./interface";
+import { DEFAULT_MESSAGE_VERSION, MESSAGE_PREFIX } from "./constants";
+import { Address } from "./address";
+
+const createKeccakHash = require("keccak");
+
+export class Message {
+    /**
+     * Actual message being signed.
+     */
+    public data: Uint8Array;
+    /**
+     * The message signature.
+     */
+    public signature?: Uint8Array;
+    /**
+     * Address of the wallet that performed the signing operation.
+     */
+    public address?: IAddress;
+    /**
+     * Number representing the message version.
+     */
+    public version: number;
+
+    constructor(options: { data: Uint8Array; signature?: Uint8Array; address?: IAddress; version?: number }) {
+        this.data = options.data;
+        this.signature = options.signature;
+        this.address = options.address;
+        this.version = options.version || DEFAULT_MESSAGE_VERSION;
+    }
+}
+
+export class MessageComputer {
+    constructor() {}
+
+    computeBytesForSigning(message: Message): Uint8Array {
+        const messageSize = Buffer.from(message.data.length.toString());
+        const signableMessage = Buffer.concat([messageSize, message.data]);
+        let bytesToHash = Buffer.concat([Buffer.from(MESSAGE_PREFIX), signableMessage]);
+
+        return createKeccakHash("keccak256").update(bytesToHash).digest();
+    }
+
+    computeBytesForVerifying(message: Message): Uint8Array {
+        return this.computeBytesForSigning(message);
+    }
+
+    packMessage(message: Message): {
+        message: string;
+        signature: string;
+        address: string;
+        version: number;
+    } {
+        return {
+            message: Buffer.from(message.data).toString("hex"),
+            signature: message.signature ? Buffer.from(message.signature).toString("hex") : "",
+            address: message.address ? message.address.bech32() : "",
+            version: message.version ? message.version : DEFAULT_MESSAGE_VERSION,
+        };
+    }
+
+    unpackMessage(packedMessage: { message: string; signature?: string; address?: string; version?: number }): Message {
+        const dataHex = this.trimHexPrefix(packedMessage.message);
+        const data = Buffer.from(dataHex, "hex");
+
+        const signatureHex = this.trimHexPrefix(packedMessage.signature || "");
+        const signature = Buffer.from(signatureHex, "hex");
+
+        let address: Address | undefined = undefined;
+        if (packedMessage.address) {
+            address = Address.fromBech32(packedMessage.address);
+        }
+
+        const version = packedMessage.version || DEFAULT_MESSAGE_VERSION;
+
+        return new Message({
+            data: data,
+            signature: signature,
+            address: address,
+            version: version,
+        });
+    }
+
+    private trimHexPrefix(data: string): string {
+        if (data.startsWith("0x") || data.startsWith("0X")) {
+            return data.slice(2);
+        }
+        return data;
+    }
+}