refactor(account-lib): use Signature type

TICKET: COIN-4724

Author: bhavidhingra

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

@@ -1,6 +1,12 @@
 import { EIP191Message } from './eip191Message';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
-import { BaseMessageBuilder, BroadcastableMessage, IMessage, MessageStandardType } from '@bitgo/sdk-core';
+import {
+  BaseMessageBuilder,
+  BroadcastableMessage,
+  deserializeSignatures,
+  IMessage,
+  MessageStandardType,
+} from '@bitgo/sdk-core';
 
 /**
  * Builder for EIP-191 messages
@@ -48,14 +54,14 @@ export class Eip191MessageBuilder extends BaseMessageBuilder {
    * @returns The parsed message
    */
   public async fromBroadcastFormat(broadcastMessage: BroadcastableMessage): Promise<IMessage> {
-    const { type, payload, signatures, signers, metadata } = broadcastMessage;
+    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,
+      signatures: deserializeSignatures(serializedSignatures),
       signers,
       metadata: {
         ...metadata,

modules/abstract-eth/test/unit/messages/eip191/eip191Message.ts

@@ -1,6 +1,6 @@
 import 'should';
 import sinon from 'sinon';
-import { MessageStandardType } from '@bitgo/sdk-core';
+import { MessageStandardType, serializeSignatures } from '@bitgo/sdk-core';
 import { fixtures } from '../fixtures';
 import { EIP191Message } from '../../../../src';
 
@@ -84,17 +84,33 @@ describe('EIP191 Message', () => {
     message.getSigners().should.containEql(fixtures.eip191.signer);
 
     // Test adding new ones
-    message.addSignature('new-signature');
+    message.addSignature({
+      publicKey: { pub: 'pub1' },
+      signature: Buffer.from('new-signature'),
+    });
     message.addSigner('new-signer');
 
-    message.getSignatures().should.containEql('new-signature');
+    message.getSignatures().should.containEql({
+      publicKey: { pub: 'pub1' },
+      signature: Buffer.from('new-signature'),
+    });
     message.getSigners().should.containEql('new-signer');
 
     // Test replacing all
-    message.setSignatures(['replaced-signature']);
+    message.setSignatures([
+      {
+        publicKey: { pub: 'pub2' },
+        signature: Buffer.from('replaced-signature'),
+      },
+    ]);
     message.setSigners(['replaced-signer']);
 
-    message.getSignatures().should.deepEqual(['replaced-signature']);
+    message.getSignatures().should.deepEqual([
+      {
+        publicKey: { pub: 'pub2' },
+        signature: Buffer.from('replaced-signature'),
+      },
+    ]);
     message.getSigners().should.deepEqual(['replaced-signer']);
   });
 
@@ -121,9 +137,10 @@ describe('EIP191 Message', () => {
 
       const broadcastFormat = await message.toBroadcastFormat();
 
+      const expectedSerializedSignatures = serializeSignatures([fixtures.eip191.signature]);
       broadcastFormat.type.should.equal(MessageStandardType.EIP191);
       broadcastFormat.payload.should.equal(fixtures.messages.validMessage);
-      broadcastFormat.signatures.should.deepEqual([fixtures.eip191.signature]);
+      broadcastFormat.serializedSignatures.should.deepEqual(expectedSerializedSignatures);
       broadcastFormat.signers.should.deepEqual([fixtures.eip191.signer]);
       broadcastFormat.metadata!.should.deepEqual(fixtures.eip191.metadata);
       broadcastFormat.signablePayload!.should.equal('test-signable-payload');
@@ -164,10 +181,11 @@ describe('EIP191 Message', () => {
 
       const broadcastString = await message.toBroadcastString();
       const parsedBroadcast = JSON.parse(broadcastString);
+      const expectedSerializedSignatures = serializeSignatures([fixtures.eip191.signature]);
 
       parsedBroadcast.type.should.equal(MessageStandardType.EIP191);
       parsedBroadcast.payload.should.equal(fixtures.messages.validMessage);
-      parsedBroadcast.signatures.should.deepEqual([fixtures.eip191.signature]);
+      parsedBroadcast.serializedSignatures.should.deepEqual(expectedSerializedSignatures);
       parsedBroadcast.signers.should.deepEqual([fixtures.eip191.signer]);
       parsedBroadcast.metadata.should.deepEqual(fixtures.eip191.metadata);
     });

modules/abstract-eth/test/unit/messages/eip191/eip191MessageBuilder.ts

@@ -1,6 +1,6 @@
 import 'should';
 import sinon from 'sinon';
-import { MessageStandardType } from '@bitgo/sdk-core';
+import { BroadcastableMessage, MessageStandardType, serializeSignatures } from '@bitgo/sdk-core';
 import { fixtures } from '../fixtures';
 import { EIP191Message, Eip191MessageBuilder } from '../../../../src';
 
@@ -79,10 +79,10 @@ describe('EIP191 Message Builder', () => {
     it('should reconstruct a message from broadcast format', async () => {
       const builder = new Eip191MessageBuilder(fixtures.coin);
 
-      const broadcastMessage = {
+      const broadcastMessage: BroadcastableMessage = {
         type: MessageStandardType.EIP191,
         payload: fixtures.messages.validMessage,
-        signatures: [fixtures.eip191.signature],
+        serializedSignatures: serializeSignatures([fixtures.eip191.signature]),
         signers: [fixtures.eip191.signer],
         metadata: fixtures.eip191.metadata,
       };
@@ -101,10 +101,10 @@ describe('EIP191 Message Builder', () => {
     it('should throw an error for incorrect message type', async () => {
       const builder = new Eip191MessageBuilder(fixtures.coin);
 
-      const broadcastMessage = {
+      const broadcastMessage: BroadcastableMessage = {
         type: MessageStandardType.UNKNOWN,
         payload: fixtures.messages.validMessage,
-        signatures: [fixtures.eip191.signature],
+        serializedSignatures: serializeSignatures([fixtures.eip191.signature]),
         signers: [fixtures.eip191.signer],
         metadata: {},
       };

modules/abstract-eth/test/unit/messages/fixtures.ts

@@ -13,8 +13,13 @@ export const fixtures = {
   },
   eip191: {
     validSignablePayload: '0x19457468657265756d205369676e6564204d6573736167653a0d48656c6c6f2c20776f726c6421',
-    signature:
-      '0x5d99b6f7f6d1f73d1a26497f2b1c89b24c0993913f86e9a2d02cd69887d9c94f3c880358579d811b21dd1b7fd9bb01c1d81d10e69f0384e675c32b39643be8921b',
+    signature: {
+      publicKey: { pub: '0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf' },
+      signature: Buffer.from(
+        '5d99b6f7f6d1f73d1a26497f2b1c89b24c0993913f86e9a2d02cd69887d9c94f3c880358579d811b21dd1b7fd9bb01c1d81d10e69f0384e675c32b39643be8921b',
+        'hex'
+      ),
+    },
     signer: '0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
     metadata: {
       encoding: 'utf8',

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

@@ -35,6 +35,33 @@ export type Signature = {
   signature: Buffer;
 };
 
+export type SerializedSignature = {
+  publicKey: string;
+  signature: string;
+};
+
+export function serializeSignature(signature: Signature): SerializedSignature {
+  return {
+    publicKey: signature.publicKey.pub,
+    signature: signature.signature.toString('base64'),
+  };
+}
+
+export function serializeSignatures(signatures: Signature[]): SerializedSignature[] {
+  return signatures.map(serializeSignature);
+}
+
+export function deserializeSignature(serialized: SerializedSignature): Signature {
+  return {
+    publicKey: { pub: serialized.publicKey },
+    signature: Buffer.from(serialized.signature, 'base64'),
+  };
+}
+
+export function deserializeSignatures(serialized: SerializedSignature[]): Signature[] {
+  return serialized.map(deserializeSignature);
+}
+
 export type KeyPairOptions = Seed | PrivateKey | PublicKey;
 
 export type BaseBuilder = BaseTransactionBuilder | BaseTransactionBuilderFactory;

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

@@ -7,12 +7,13 @@ import {
   MessageStandardType,
 } from '../../../bitgo';
 import { IMessage } from './iface';
+import { serializeSignatures, Signature } from '../iface';
 
 export abstract class BaseMessage implements IMessage {
   protected coinConfig: Readonly<CoinConfig>;
   protected type: MessageStandardType;
   protected payload: MessagePayload;
-  protected signatures: string[] = [];
+  protected signatures: Signature[] = [];
   protected signers: string[] = [];
   protected signablePayload?: string | Buffer;
   protected metadata?: MessageMetadata;
@@ -30,7 +31,11 @@ export abstract class BaseMessage implements IMessage {
     this.metadata = options.metadata || {};
 
     if (options.signatures) {
-      this.signatures = [...options.signatures];
+      // Deep copy each Signature object, including the Buffer
+      this.signatures = options.signatures.map((sig) => ({
+        publicKey: { ...sig.publicKey },
+        signature: Buffer.from(sig.signature),
+      }));
     }
     if (options.signers) {
       this.signers = [...options.signers];
@@ -86,23 +91,23 @@ export abstract class BaseMessage implements IMessage {
   /**
    * Gets all signatures associated with this message
    */
-  getSignatures(): string[] {
+  getSignatures(): Signature[] {
     return [...this.signatures];
   }
 
   /**
    * Sets signatures for this message
    * @param signatures Array of signatures to set
    */
-  setSignatures(signatures: string[]): void {
+  setSignatures(signatures: Signature[]): void {
     this.signatures = [...signatures];
   }
 
   /**
    * Adds a signature to this message
    * @param signature The signature to add
    */
-  addSignature(signature: string): void {
+  addSignature(signature: Signature): void {
     this.signatures.push(signature);
   }
 
@@ -121,20 +126,27 @@ export abstract class BaseMessage implements IMessage {
     if (this.signatures.length === 0) {
       throw new Error('No signatures available for broadcast. Call setSignatures or addSignature first.');
     }
-
     if (this.signers.length === 0) {
       throw new Error('No signers available for broadcast. Call setSigners or addSigner first.');
     }
+    let signablePayload: string | undefined;
+    if (this.signablePayload) {
+      if (Buffer.isBuffer(this.signablePayload)) {
+        signablePayload = this.signablePayload.toString('base64');
+      } else {
+        signablePayload = Buffer.from(String(this.signablePayload)).toString('base64');
+      }
+    }
 
     return {
       type: this.type,
       payload: this.payload,
-      signatures: this.signatures,
-      signers: this.signers,
+      serializedSignatures: serializeSignatures(this.signatures),
+      signers: [...this.signers],
       metadata: {
         ...(this.metadata ? JSON.parse(JSON.stringify(this.metadata)) : {}), // deep copy to avoid mutation
       },
-      signablePayload: this.signablePayload,
+      signablePayload,
     };
   }
 

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

@@ -1,6 +1,7 @@
 import { BroadcastableMessage, MessagePayload, MessageStandardType } from '../../../bitgo';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { IMessage, IMessageBuilder } from './iface';
+import { Signature } from '../iface';
 
 /**
  * Base Message Builder
@@ -9,7 +10,7 @@ export abstract class BaseMessageBuilder implements IMessageBuilder {
   protected coinConfig: Readonly<CoinConfig>;
   protected payload: MessagePayload = '';
   protected type: MessageStandardType;
-  protected signatures: string[] = [];
+  protected signatures: Signature[] = [];
   protected signers: string[] = [];
   protected metadata?: Record<string, unknown> = {};
   protected digest?: string;
@@ -72,17 +73,21 @@ export abstract class BaseMessageBuilder implements IMessageBuilder {
     return this;
   }
 
-  public getSignatures(): string[] {
+  public getSignatures(): Signature[] {
     return this.signatures;
   }
 
-  public setSignatures(value: string[]): IMessageBuilder {
-    this.signatures = value;
+  public setSignatures(signatures: Signature[]): IMessageBuilder {
+    this.signatures = signatures;
     return this;
   }
 
-  public addSignature(signature: string): IMessageBuilder {
-    if (!this.signatures.includes(signature)) {
+  public addSignature(signature: Signature): IMessageBuilder {
+    if (
+      !this.signatures.some(
+        (sig) => sig.publicKey.pub === signature.publicKey.pub && sig.signature.equals(signature.signature)
+      )
+    ) {
       this.signatures.push(signature);
     }
     return this;

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

@@ -1,4 +1,5 @@
 import { BroadcastableMessage, MessageMetadata, MessagePayload, MessageStandardType } from '../../../bitgo';
+import { Signature } from '../iface';
 
 /**
  * Represents a built message that can be signed
@@ -39,19 +40,19 @@ export interface IMessage {
   /**
    * Gets all signatures associated with this message
    */
-  getSignatures(): string[];
+  getSignatures(): Signature[];
 
   /**
    * Sets signatures for this message
    * @param signatures Array of signatures to set
    */
-  setSignatures(signatures: string[]): void;
+  setSignatures(signatures: Signature[]): void;
 
   /**
    * Adds a signature to this message
    * @param signature The signature to add
    */
-  addSignature(signature: string): void;
+  addSignature(signature: Signature): void;
 
   /**
    * Returns the payload that should be signed
@@ -98,14 +99,14 @@ export interface IMessageBuilder {
    * @param signatures The signatures to add
    * @returns The builder instance for chaining
    */
-  setSignatures(signatures: string[]): IMessageBuilder;
+  setSignatures(signatures: Signature[]): IMessageBuilder;
 
   /**
    * Adds a signature to the message
    * @param signature The signature to add
    * @returns The builder instance for chaining
    */
-  addSignature(signature: string): IMessageBuilder;
+  addSignature(signature: Signature): IMessageBuilder;
 
   /**
    * Sets the signers for the message

modules/sdk-core/src/bitgo/utils/messageTypes.ts

@@ -1,11 +1,13 @@
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { SerializedSignature, Signature } from '../../account-lib';
 
 /**
  * Supported message signing standard types
  */
 export enum MessageStandardType {
   UNKNOWN = 'UNKNOWN',
   EIP191 = 'EIP191',
+  CIP8 = 'CIP8',
 }
 
 export type MessagePayload = string;
@@ -17,10 +19,10 @@ export type MessageMetadata = Record<string, unknown>;
 export interface BroadcastableMessage {
   type: MessageStandardType;
   payload: MessagePayload;
-  signatures: string[];
+  serializedSignatures: SerializedSignature[];
   signers: string[]; // list of addresses or public keys of the signers
   metadata?: MessageMetadata;
-  signablePayload?: string | Buffer;
+  signablePayload?: string;
 }
 
 /**
@@ -32,6 +34,6 @@ export interface MessageOptions {
   type?: MessageStandardType;
   signablePayload?: string | Buffer;
   metadata?: MessageMetadata;
-  signatures?: string[];
+  signatures?: Signature[];
   signers?: string[];
 }