refactor(account-lib): common build() function in BaseMessage class

TICKET: COIN-4737

Author: bhavidhingra

modules/abstract-eth/src/lib/messages/eip191/eip191MessageBuilder.ts

@@ -1,6 +1,6 @@
 import { EIP191Message } from './eip191Message';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
-import { BaseMessageBuilder, IMessage, MessageStandardType } from '@bitgo/sdk-core';
+import { BaseMessageBuilder, IMessage, MessageOptions, MessageStandardType } from '@bitgo/sdk-core';
 
 /**
  * Builder for EIP-191 messages
@@ -15,30 +15,11 @@ export class Eip191MessageBuilder extends BaseMessageBuilder {
   }
 
   /**
-   * Build a signable message using the EIP-191 standard
-   * with previously set input and metadata
-   * @returns A signable message
+   * Builds an EIP-191 message instance with the provided options
+   * @param options Options to create the message
+   * @returns A Promise that resolves to an EIP191Message instance
    */
-  public async build(): Promise<IMessage> {
-    try {
-      if (!this.payload) {
-        throw new Error('Message payload must be set before building the message');
-      }
-      return new EIP191Message({
-        coinConfig: this.coinConfig,
-        payload: this.payload,
-        signatures: this.signatures,
-        signers: this.signers,
-        metadata: {
-          ...this.metadata,
-          encoding: 'utf8',
-        },
-      });
-    } catch (err) {
-      if (err instanceof Error) {
-        throw err;
-      }
-      throw new Error('Failed to build EIP-191 message');
-    }
+  async buildMessage(options: MessageOptions): Promise<IMessage> {
+    return new EIP191Message(options);
   }
 }

modules/account-lib/test/unit/fixtures.ts

@@ -24,17 +24,8 @@ export class MockMessageBuilder extends BaseMessageBuilder {
     super(coinConfig, type);
   }
 
-  async build(): Promise<IMessage> {
-    return new MockMessage({
-      coinConfig: this.coinConfig,
-      payload: this.payload,
-      type: this.type,
-      signatures: this.signatures,
-      signers: this.signers,
-      metadata: {
-        ...this.metadata,
-      },
-    });
+  async buildMessage(options: MessageOptions): Promise<IMessage> {
+    return new MockMessage(options);
   }
 
   async fromBroadcastFormat(broadcastMessage: any): Promise<IMessage> {

modules/sdk-coin-ada/src/lib/messages/cip8/cip8Message.ts

@@ -13,54 +13,28 @@ export class Cip8Message extends BaseMessage {
     });
   }
 
-  /**
-   * Validates required fields and returns common setup objects
-   * @private
-   */
-  private validateAndGetCommonSetup() {
-    if (!this.payload) {
-      throw new Error('Payload is required to build a CIP8 message');
-    }
-    if (!this.signers || this.signers.length === 0) {
-      throw new Error('A signer address is required to build a CIP8 message');
-    }
-
-    let cslAddress: CardanoSL.Address;
-    try {
-      cslAddress = CardanoSL.Address.from_bech32(this.signers[0]);
-    } catch (error) {
-      // Convert string errors to proper Error objects
-      if (typeof error === 'string') {
-        throw new Error(`Invalid signer address: ${error}`);
-      }
-      throw error;
-    }
-
-    const addressCborBytes = cslAddress.to_bytes();
-
-    return { addressCborBytes };
-  }
-
   /**
    * Returns the hash of the CIP-8 prefixed message
    */
   async getSignablePayload(): Promise<string | Buffer> {
     if (!this.signablePayload) {
-      this.signablePayload = this.buildSignablePayload();
+      const { addressCborBytes } = this.validateAndGetCommonSetup();
+      const { sigStructureCborBytes } = createCSLSigStructure(addressCborBytes, this.payload);
+      this.signablePayload = Buffer.from(sigStructureCborBytes);
     }
     return this.signablePayload;
   }
 
-  /**
-   * Builds the signable payload for a CIP8 message
-   * @returns The signable payload as a Buffer
+  /*
+   * Returns broadcastable signatures in COSE format according to CIP8 standard
+   *
+   * This method transforms the internal signatures into a format suitable for broadcasting
+   * by constructing COSE (CBOR Object Signing and Encryption) objects that comply with
+   * the CIP8 message signing specification.
+   *
+   * @returns Array of signatures with COSE-formatted signature data and public keys
+   * @throws Error if required setup validation fails
    */
-  buildSignablePayload(): string | Buffer {
-    const { addressCborBytes } = this.validateAndGetCommonSetup();
-    const { sigStructureCborBytes } = createCSLSigStructure(addressCborBytes, this.payload);
-    return Buffer.from(sigStructureCborBytes);
-  }
-
   getBroadcastableSignatures(): Signature[] {
     if (!this.signatures.length) {
       return [];
@@ -88,4 +62,31 @@ export class Cip8Message extends BaseMessage {
       },
     ];
   }
+
+  /**
+   * Validates required fields and returns common setup objects
+   * @private
+   */
+  private validateAndGetCommonSetup() {
+    if (!this.payload) {
+      throw new Error('Payload is required to build a CIP8 message');
+    }
+    if (!this.signers || this.signers.length === 0) {
+      throw new Error('A signer address is required to build a CIP8 message');
+    }
+
+    let cslAddress: CardanoSL.Address;
+    try {
+      cslAddress = CardanoSL.Address.from_bech32(this.signers[0]);
+    } catch (error) {
+      // Convert string errors to proper Error objects
+      if (typeof error === 'string') {
+        throw new Error(`Invalid signer address: ${error}`);
+      }
+      throw error;
+    }
+
+    const addressCborBytes = cslAddress.to_bytes();
+    return { addressCborBytes };
+  }
 }

modules/sdk-coin-ada/src/lib/messages/cip8/cip8MessageBuilder.ts

@@ -1,6 +1,6 @@
 import { Cip8Message } from './cip8Message';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
-import { BaseMessageBuilder, IMessage, MessageStandardType } from '@bitgo/sdk-core';
+import { BaseMessageBuilder, IMessage, MessageOptions, MessageStandardType } from '@bitgo/sdk-core';
 
 /**
  * Builder for CIP-8 messages
@@ -15,30 +15,11 @@ export class Cip8MessageBuilder extends BaseMessageBuilder {
   }
 
   /**
-   * Build a signable message using the CIP-8 standard
-   * with previously set input and metadata
-   * @returns A signable message
+   * Builds a CIP-8 message instance with the provided options
+   * @param options Options to create the message
+   * @returns A Promise that resolves to a Cip8Message instance
    */
-  public async build(): Promise<IMessage> {
-    try {
-      if (!this.payload) {
-        throw new Error('Message payload must be set before building the message');
-      }
-      return new Cip8Message({
-        coinConfig: this.coinConfig,
-        payload: this.payload,
-        signatures: this.signatures,
-        signers: this.signers,
-        metadata: {
-          ...this.metadata,
-          encoding: 'utf8',
-        },
-      });
-    } catch (err) {
-      if (err instanceof Error) {
-        throw err;
-      }
-      throw new Error('Failed to build CIP-8 message');
-    }
+  async buildMessage(options: MessageOptions): Promise<IMessage> {
+    return new Cip8Message(options);
   }
 }

modules/sdk-coin-ada/test/unit/messages/cip8/cip8Message.ts

@@ -105,7 +105,6 @@ describe('Cip8Message', function () {
 
     it('should cache signable payload', async function () {
       const message = new Cip8Message(createDefaultMessageOptions());
-      const buildSignablePayloadSpy = sandbox.spy(message as any, 'buildSignablePayload');
 
       const payload1 = await message.getSignablePayload();
       const payload2 = await message.getSignablePayload();
@@ -115,27 +114,6 @@ describe('Cip8Message', function () {
 
       // Payloads should be the same
       should.equal(payload1, payload2);
-
-      // buildSignablePayload should be called only once
-      buildSignablePayloadSpy.calledOnce.should.be.true();
-    });
-  });
-
-  describe('buildSignablePayload', function () {
-    it('should create a buffer from signature structure', function () {
-      const message = new Cip8Message(createDefaultMessageOptions());
-      const payload = (message as any).buildSignablePayload();
-
-      should.exist(payload);
-      should.ok(Buffer.isBuffer(payload));
-    });
-
-    it('should throw when validation fails', async function () {
-      const options = createDefaultMessageOptions();
-      options.payload = undefined as any;
-      const message = new Cip8Message(options);
-
-      await should(message.getSignablePayload()).be.rejectedWith(`Payload is required to build a CIP8 message`);
     });
   });
 

modules/sdk-core/src/account-lib/baseCoin/messages/baseMessage.ts

@@ -25,8 +25,8 @@ export abstract class BaseMessage implements IMessage {
    */
   protected constructor(options: MessageOptions) {
     this.coinConfig = options.coinConfig;
+    this.payload = options.payload;
     this.type = options.type || MessageStandardType.UNKNOWN;
-    this.payload = options.payload || '';
     this.signablePayload = options.signablePayload;
     this.metadata = options.metadata || {};
 
@@ -117,6 +117,9 @@ export abstract class BaseMessage implements IMessage {
    */
   abstract getSignablePayload(): Promise<string | Buffer>;
 
+  /**
+   * Gets the signatures in a format suitable for broadcasting
+   */
   getBroadcastableSignatures(): Signature[] {
     return this.signatures;
   }

modules/sdk-core/src/account-lib/baseCoin/messages/baseMessageBuilder.ts

@@ -1,4 +1,4 @@
-import { BroadcastableMessage, MessagePayload, MessageStandardType } from '../../../bitgo';
+import { BroadcastableMessage, MessageOptions, MessagePayload, MessageStandardType } from '../../../bitgo';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { IMessage, IMessageBuilder } from './iface';
 import { deserializeSignatures, Signature } from '../iface';
@@ -120,10 +120,33 @@ export abstract class BaseMessageBuilder implements IMessageBuilder {
 
   /**
    * Builds a message using the previously set payload and metadata
-   * This abstract method must be implemented by each specific builder
    * @returns A Promise resolving to the built IMessage
    */
-  abstract build(): Promise<IMessage>;
+  public async build(): Promise<IMessage> {
+    try {
+      if (!this.payload) {
+        throw new Error('Message payload must be set before building the message');
+      }
+      return this.buildMessage({
+        coinConfig: this.coinConfig,
+        payload: this.payload,
+        type: this.type,
+        signatures: this.signatures,
+        signers: this.signers,
+        metadata: {
+          ...this.metadata,
+          encoding: 'utf8',
+        },
+      });
+    } catch (err) {
+      if (err instanceof Error) {
+        throw err;
+      }
+      throw new Error(`Failed to build message of type ${this.type}`);
+    }
+  }
+
+  protected abstract buildMessage(options: MessageOptions): Promise<IMessage>;
 
   /**
    * Parse a broadcastable message back into a message

modules/sdk-core/src/account-lib/baseCoin/messages/simple/simpleMessageBuilder.ts

@@ -1,7 +1,7 @@
 import { SimpleMessage } from './simpleMessage';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { BaseMessageBuilder } from '../baseMessageBuilder';
-import { MessageStandardType } from '../../../../bitgo';
+import { MessageOptions, MessageStandardType } from '../../../../bitgo';
 import { IMessage } from '../iface';
 
 /**
@@ -17,30 +17,11 @@ export class SimpleMessageBuilder extends BaseMessageBuilder {
   }
 
   /**
-   * Build a signable message using the EIP-191 standard
-   * with previously set input and metadata
-   * @returns A signable message
+   * Builds a SimpleMessage instance with the provided options
+   * @param options Options to create the message
+   * @returns A Promise that resolves to a SimpleMessage instance
    */
-  public async build(): Promise<IMessage> {
-    try {
-      if (!this.payload) {
-        throw new Error('Message payload must be set before building the message');
-      }
-      return new SimpleMessage({
-        coinConfig: this.coinConfig,
-        payload: this.payload,
-        signatures: this.signatures,
-        signers: this.signers,
-        metadata: {
-          ...this.metadata,
-          encoding: 'utf8',
-        },
-      });
-    } catch (err) {
-      if (err instanceof Error) {
-        throw err;
-      }
-      throw new Error('Failed to build EIP-191 message');
-    }
+  public async buildMessage(options: MessageOptions): Promise<IMessage> {
+    return new SimpleMessage(options);
   }
 }

modules/sdk-core/test/unit/account-lib/baseCoin/messages/baseMessageBuilder.ts

@@ -73,7 +73,7 @@ describe('Base Message Builder', () => {
 
   it('should build a message with the correct properties', async () => {
     const payload = 'test message';
-    const metadata = { foo: 'bar' };
+    const metadata = { foo: 'bar', encoding: 'utf8' };
     const signatures = [
       {
         publicKey: { pub: 'pubKey1' },
@@ -107,7 +107,7 @@ describe('Base Message Builder', () => {
 
   it('should correctly handle toBroadcastFormat', async () => {
     const payload = 'hello world';
-    const metadata = { version: '1.0' };
+    const metadata = { version: '1.0', encoding: 'utf8' };
     const signatures = [
       {
         publicKey: { pub: 'pubKey1' },
@@ -152,7 +152,7 @@ describe('Base Message Builder', () => {
         },
       ],
       signers: ['addr1', 'addr2'],
-      metadata: { chainId: 1 },
+      metadata: { chainId: 1, encoding: 'utf8' },
     };
 
     const message = await builder.fromBroadcastFormat(broadcastMessage);
@@ -184,7 +184,7 @@ describe('Base Message Builder', () => {
       payload: payload,
       serializedSignatures: serializeSignatures(signatures),
       signers: signers,
-      metadata: {},
+      metadata: { encoding: 'utf8' },
     });
 
     should.equal(broadcastString, expectedJson);