feat(account-lib): register message builder factory

TICKET: COIN-4592

Author: bhavidhingra

.gitcommitscopes

@@ -1,3 +1,4 @@
+account-lib
 sdk-coin-rune
 sdk-coin-sui
 sdk-core

modules/abstract-eth/src/lib/messages/messageBuilderFactory.ts

@@ -1,4 +1,4 @@
-import { Eip191MessageBuilder } from './eip191/eip191MessageBuilder';
+import { Eip191MessageBuilder } from './eip191';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { BaseMessageBuilderFactory, IMessageBuilder, MessageStandardType } from '@bitgo/sdk-core';
 

modules/account-lib/src/index.ts

@@ -7,6 +7,8 @@ import {
   Eddsa,
   accountLibBaseCoin,
   acountLibCrypto,
+  BaseMessageBuilderFactory,
+  BuildMessageError,
 } from '@bitgo/sdk-core';
 import { BaseCoin as CoinConfig, CoinFeature, coins } from '@bitgo/statics';
 export { Ed25519BIP32, Eddsa };
@@ -311,6 +313,11 @@ const coinBuilderMap = {
   tvet: Vet.TransactionBuilderFactory,
 };
 
+const coinMessageBuilderFactoryMap = {
+  eth: Eth.MessageBuilderFactory,
+  hteth: Eth.MessageBuilderFactory,
+};
+
 coins
   .filter((coin) => coin.features.includes(CoinFeature.SHARED_EVM_SDK))
   .forEach((coin) => {
@@ -337,6 +344,14 @@ export function getBuilder(coinName: string): BaseBuilder {
   return new builderClass(coins.get(coinName));
 }
 
+export function getMessageBuilderFactory(coinName: string): BaseMessageBuilderFactory {
+  const messageBuilderFactoryClass = coinMessageBuilderFactoryMap[coinName];
+  if (!messageBuilderFactoryClass) {
+    throw new BuildMessageError(`Message builder factory for coin ${coinName} not supported`);
+  }
+  return new messageBuilderFactoryClass(coins.get(coinName));
+}
+
 /**
  * Register a new coin instance with its builder factory
  *
@@ -354,3 +369,20 @@ export function register<T extends BaseTransactionBuilderFactory>(
   coinBuilderMap[coinName] = builderFactory; // For now register the constructor function until reimplement getBuilder method
   return factory;
 }
+
+/**
+ * Register a new coin instance with its message builder factory constructor.
+ *
+ * @param {string} coinName coin name as it was registered in @bitgo/statics
+ * @param {any} messageBuilderFactory the message builder factory class for that coin
+ * @returns {any} the message builder factory instance for the registered coin
+ */
+export function registerMessageBuilderFactory<T extends BaseMessageBuilderFactory>(
+  coinName: string,
+  messageBuilderFactory: { new (_coinConfig: Readonly<CoinConfig>): T },
+): T {
+  const coinConfig = coins.get(coinName);
+  const factory = new messageBuilderFactory(coinConfig);
+  coinMessageBuilderFactoryMap[coinName] = messageBuilderFactory;
+  return factory;
+}

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

@@ -0,0 +1,63 @@
+import { BaseCoin } from '@bitgo/statics';
+import {
+  BaseMessage,
+  BaseMessageBuilder,
+  BaseMessageBuilderFactory,
+  IMessage,
+  IMessageBuilder,
+  MessageOptions,
+  MessageStandardType,
+} from '@bitgo/sdk-core';
+
+export class MockMessageBuilderFactory extends BaseMessageBuilderFactory {
+  constructor(coinConfig: Readonly<BaseCoin>) {
+    super(coinConfig);
+  }
+
+  getMessageBuilder(type: MessageStandardType): IMessageBuilder {
+    return new MockMessageBuilder(this.coinConfig, type);
+  }
+}
+
+export class MockMessageBuilder extends BaseMessageBuilder {
+  constructor(coinConfig: Readonly<BaseCoin>, type: MessageStandardType = MessageStandardType.UNKNOWN) {
+    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 fromBroadcastFormat(broadcastMessage: any): Promise<IMessage> {
+    this.setType(broadcastMessage.type);
+    this.setPayload(broadcastMessage.payload);
+    this.setSignatures(broadcastMessage.signatures || []);
+    this.setSigners(broadcastMessage.signers || []);
+    if (broadcastMessage.metadata) {
+      this.setMetadata(broadcastMessage.metadata);
+    }
+    return this.build();
+  }
+}
+
+export class MockMessage extends BaseMessage {
+  constructor(options: MessageOptions) {
+    super(options);
+  }
+
+  async getSignablePayload(): Promise<string | Buffer> {
+    if (this.signablePayload) {
+      return this.signablePayload;
+    }
+    return Buffer.from(this.payload);
+  }
+}

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

@@ -0,0 +1,59 @@
+import assert from 'assert';
+import should from 'should';
+import sinon from 'sinon';
+import { getMessageBuilderFactory, registerMessageBuilderFactory } from '../../src';
+import { BaseMessageBuilderFactory, BuildMessageError } from '@bitgo/sdk-core';
+import { coins, BaseCoin } from '@bitgo/statics';
+import { MockMessageBuilderFactory } from './fixtures';
+
+describe('Message Builder Factory', () => {
+  describe('getMessageBuilderFactory', () => {
+    it('should fail to instantiate an unsupported coin', () => {
+      assert.throws(
+        () => getMessageBuilderFactory('fakeUnsupported'),
+        (e: Error) => {
+          return (
+            e instanceof BuildMessageError &&
+            e.message === 'Message builder factory for coin fakeUnsupported not supported'
+          );
+        },
+      );
+    });
+
+    it('should succeed for supported coins', () => {
+      const ethFactory = getMessageBuilderFactory('eth');
+      should.exist(ethFactory);
+      ethFactory.should.be.instanceof(BaseMessageBuilderFactory);
+
+      // Verify hteth is also supported
+      const htethFactory = getMessageBuilderFactory('hteth');
+      should.exist(htethFactory);
+      htethFactory.should.be.instanceof(BaseMessageBuilderFactory);
+    });
+  });
+
+  describe('registerMessageBuilderFactory', () => {
+    // Mock message builder that implements required abstract methods
+
+    it('should register a new message builder factory', () => {
+      const coinName = 'fakeTestCoin';
+      const mockCoin = sinon.createStubInstance(BaseCoin);
+      sinon
+        .stub(coins, 'get')
+        .withArgs(coinName)
+        .returns(mockCoin as unknown as BaseCoin);
+
+      const factory = registerMessageBuilderFactory(coinName, MockMessageBuilderFactory);
+      should.exist(factory);
+      factory.should.be.instanceof(MockMessageBuilderFactory);
+
+      // Verify we can get it back
+      const retrievedFactory = getMessageBuilderFactory(coinName);
+      should.exist(retrievedFactory);
+      retrievedFactory.should.be.instanceof(MockMessageBuilderFactory);
+
+      // Restore the stub
+      sinon.restore();
+    });
+  });
+});

modules/sdk-coin-eth/src/eth.ts

@@ -43,7 +43,7 @@ import { BaseCoin as StaticsBaseCoin, coins } from '@bitgo/statics';
 import type * as EthTxLib from '@ethereumjs/tx';
 import { BigNumber } from 'bignumber.js';
 
-import { TransactionBuilder } from './lib/transactionBuilder';
+import { TransactionBuilder } from './lib';
 import { Erc20Token } from './erc20Token';
 
 export {

modules/sdk-coin-eth/src/lib/index.ts

@@ -4,6 +4,7 @@ export * from '@bitgo/abstract-eth';
 // exporting Ethereum TransactionBuilder and TransferBuilder
 export { TransactionBuilder } from './transactionBuilder';
 export { TransferBuilder } from './transferBuilder';
+export * from './messages';
 
 // for Backwards Compatibility
 import { Interface, Utils } from '@bitgo/abstract-eth';

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

@@ -0,0 +1,3 @@
+import { MessageBuilderFactory } from '@bitgo/abstract-eth';
+
+export { MessageBuilderFactory };

modules/sdk-core/src/account-lib/baseCoin/errors.ts

@@ -32,6 +32,12 @@ export class BuildTransactionError extends ExtendableError {
   }
 }
 
+export class BuildMessageError extends ExtendableError {
+  constructor(message: string) {
+    super(message);
+  }
+}
+
 export class UtilsError extends ExtendableError {
   constructor(message: string) {
     super(message);

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

@@ -2,7 +2,7 @@ import { BaseCoin } from '@bitgo/statics';
 import sinon from 'sinon';
 import should from 'should';
 import { MessageStandardType } from '../../../../../src';
-import { messageSamples, TestBaseMessage } from './fixtures';
+import { messageSamples, TestMessage } from './fixtures';
 
 describe('Base Message', () => {
   let coinConfig: sinon.SinonStubbedInstance<BaseCoin>;
@@ -12,7 +12,7 @@ describe('Base Message', () => {
   });
 
   it('should initialize with default values', () => {
-    const message = new TestBaseMessage({
+    const message = new TestMessage({
       coinConfig,
       payload: '',
     });
@@ -27,7 +27,7 @@ describe('Base Message', () => {
   it('should initialize with provided values', () => {
     const { payload, type, metadata, signers, signatures } = messageSamples.eip191;
 
-    const message = new TestBaseMessage({
+    const message = new TestMessage({
       coinConfig,
       payload,
       type,
@@ -44,10 +44,10 @@ describe('Base Message', () => {
   });
 
   describe('Getters and Setters', () => {
-    let message: TestBaseMessage;
+    let message: TestMessage;
 
     beforeEach(() => {
-      message = new TestBaseMessage({
+      message = new TestMessage({
         coinConfig,
         payload: 'test',
       });
@@ -111,7 +111,7 @@ describe('Base Message', () => {
   describe('getSignablePayload', () => {
     it('should return the signablePayload if set', async () => {
       const customSignablePayload = '0xabcdef123456';
-      const message = new TestBaseMessage({
+      const message = new TestMessage({
         coinConfig,
         payload: 'original payload',
         signablePayload: customSignablePayload,
@@ -123,7 +123,7 @@ describe('Base Message', () => {
 
     it('should return the payload as buffer if signablePayload is not set', async () => {
       const payload = 'test payload';
-      const message = new TestBaseMessage({
+      const message = new TestMessage({
         coinConfig,
         payload,
       });
@@ -135,7 +135,7 @@ describe('Base Message', () => {
 
   describe('toBroadcastFormat', () => {
     it('should throw an error if no signatures are available', async () => {
-      const message = new TestBaseMessage({
+      const message = new TestMessage({
         coinConfig,
         payload: 'test',
         signers: ['addr1'],
@@ -147,7 +147,7 @@ describe('Base Message', () => {
     });
 
     it('should throw an error if no signers are available', async () => {
-      const message = new TestBaseMessage({
+      const message = new TestMessage({
         coinConfig,
         payload: 'test',
         signatures: ['sig1'],
@@ -162,7 +162,7 @@ describe('Base Message', () => {
       const { payload, type, metadata, signers, signatures } = messageSamples.eip191;
       const customSignablePayload = Buffer.from('custom signable payload');
 
-      const message = new TestBaseMessage({
+      const message = new TestMessage({
         coinConfig,
         payload,
         type,
@@ -193,7 +193,7 @@ describe('Base Message', () => {
         },
       };
 
-      const message = new TestBaseMessage({
+      const message = new TestMessage({
         coinConfig,
         payload: 'test',
         metadata: nestedMetadata,
@@ -219,7 +219,7 @@ describe('Base Message', () => {
     it('should serialize the broadcastable format to JSON string', async () => {
       const { payload, type, metadata, signers, signatures } = messageSamples.eip191;
 
-      const message = new TestBaseMessage({
+      const message = new TestMessage({
         coinConfig,
         payload,
         type,