Merge pull request #6396 from BitGo/coin-4737-sol-message-builder

feat(sdk-core): add simple message builder for sol

Author: bhavidhingra

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

@@ -1,12 +1,6 @@
 import { EIP191Message } from './eip191Message';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
-import {
-  BaseMessageBuilder,
-  BroadcastableMessage,
-  deserializeSignatures,
-  IMessage,
-  MessageStandardType,
-} from '@bitgo/sdk-core';
+import { BaseMessageBuilder, IMessage, MessageOptions, MessageStandardType } from '@bitgo/sdk-core';
 
 /**
  * Builder for EIP-191 messages
@@ -21,52 +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');
-    }
-  }
-
-  /**
-   * Parse a broadcastable message back into a message
-   * @param broadcastMessage The broadcastable message to parse
-   * @returns The parsed message
-   */
-  public async fromBroadcastFormat(broadcastMessage: BroadcastableMessage): Promise<IMessage> {
-    const { type, payload, serializedSignatures, signers, metadata } = broadcastMessage;
-    if (type !== MessageStandardType.EIP191) {
-      throw new Error(`Invalid message type, expected ${MessageStandardType.EIP191}`);
-    }
-    return new EIP191Message({
-      coinConfig: this.coinConfig,
-      payload,
-      signatures: deserializeSignatures(serializedSignatures),
-      signers,
-      metadata: {
-        ...metadata,
-        encoding: 'utf8',
-      },
-    });
+  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,12 +1,6 @@
 import { Cip8Message } from './cip8Message';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
-import {
-  BaseMessageBuilder,
-  BroadcastableMessage,
-  deserializeSignatures,
-  IMessage,
-  MessageStandardType,
-} from '@bitgo/sdk-core';
+import { BaseMessageBuilder, IMessage, MessageOptions, MessageStandardType } from '@bitgo/sdk-core';
 
 /**
  * Builder for CIP-8 messages
@@ -21,52 +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');
-    }
-  }
-
-  /**
-   * Parse a broadcastable message back into a message
-   * @param broadcastMessage The broadcastable message to parse
-   * @returns The parsed message
-   */
-  public async fromBroadcastFormat(broadcastMessage: BroadcastableMessage): Promise<IMessage> {
-    const { type, payload, serializedSignatures, signers, metadata } = broadcastMessage;
-    if (type !== MessageStandardType.CIP8) {
-      throw new Error(`Invalid message type, expected ${MessageStandardType.CIP8}`);
-    }
-    return new Cip8Message({
-      coinConfig: this.coinConfig,
-      payload,
-      signatures: deserializeSignatures(serializedSignatures),
-      signers,
-      metadata: {
-        ...metadata,
-        encoding: 'utf8',
-      },
-    });
+  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-coin-sol/src/lib/index.ts

@@ -18,3 +18,4 @@ export { TransferBuilder } from './transferBuilder';
 export { TransferBuilderV2 } from './transferBuilderV2';
 export { WalletInitializationBuilder } from './walletInitializationBuilder';
 export { Interface, Utils };
+export { MessageBuilderFactory } from './messages';

modules/sdk-coin-sol/src/lib/messages/index.ts

@@ -0,0 +1 @@
+export * from './messageBuilderFactory';

modules/sdk-coin-sol/src/lib/messages/messageBuilderFactory.ts

@@ -0,0 +1,17 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { BaseMessageBuilderFactory, IMessageBuilder, MessageStandardType, SimpleMessageBuilder } from '@bitgo/sdk-core';
+
+export class MessageBuilderFactory extends BaseMessageBuilderFactory {
+  constructor(coinConfig: Readonly<CoinConfig>) {
+    super(coinConfig);
+  }
+
+  public getMessageBuilder(type: MessageStandardType): IMessageBuilder {
+    switch (type) {
+      case MessageStandardType.SIMPLE:
+        return new SimpleMessageBuilder(this.coinConfig);
+      default:
+        throw new Error(`Invalid message standard ${type}`);
+    }
+  }
+}

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;
   }