feat(abstract-eth): support eip712 signing

Ticket: SC-2622

Author: benkelcher-bitgo

modules/abstract-eth/src/lib/messages/eip712/eip712Message.ts

@@ -0,0 +1,33 @@
+import { BaseMessage, MessageOptions, MessageStandardType } from '@bitgo/sdk-core';
+import { SignTypedDataVersion, TypedDataUtils } from '@metamask/eth-sig-util';
+
+export class EIP712Message extends BaseMessage {
+  constructor(options: MessageOptions) {
+    super({
+      ...options,
+      type: MessageStandardType.EIP712,
+    });
+  }
+
+  async getSignablePayload(): Promise<string | Buffer> {
+    const data = JSON.parse(this.payload);
+    const sanitizedData = TypedDataUtils.sanitizeData(data);
+    const parts: Buffer[] = [];
+
+    parts.push(Buffer.from('1901', 'hex'));
+    parts.push(TypedDataUtils.eip712DomainHash(data, SignTypedDataVersion.V4));
+    if (sanitizedData.primaryType !== 'EIP712Domain') {
+      parts.push(
+        TypedDataUtils.hashStruct(
+          sanitizedData.primaryType as string,
+          sanitizedData.message,
+          sanitizedData.types,
+          SignTypedDataVersion.V4
+        )
+      );
+    }
+
+    this.signablePayload = Buffer.concat(parts);
+    return this.signablePayload;
+  }
+}

modules/abstract-eth/src/lib/messages/eip712/eip712MessageBuilder.ts

@@ -0,0 +1,13 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { BaseMessageBuilder, IMessage, MessageOptions, MessageStandardType } from '@bitgo/sdk-core';
+import { EIP712Message } from './eip712Message';
+
+export class Eip712MessageBuilder extends BaseMessageBuilder {
+  public constructor(_coinConfig: Readonly<CoinConfig>) {
+    super(_coinConfig, MessageStandardType.EIP712);
+  }
+
+  async buildMessage(options: MessageOptions): Promise<IMessage> {
+    return new EIP712Message(options);
+  }
+}

modules/abstract-eth/src/lib/messages/eip712/index.ts

@@ -0,0 +1,2 @@
+export * from './eip712Message';
+export * from './eip712MessageBuilder';

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

@@ -1,2 +1,3 @@
 export * from './messageBuilderFactory';
 export * from './eip191';
+export * from './eip712';

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

@@ -1,4 +1,5 @@
 import { Eip191MessageBuilder } from './eip191';
+import { Eip712MessageBuilder } from './eip712';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { BaseMessageBuilderFactory, IMessageBuilder, MessageStandardType } from '@bitgo/sdk-core';
 
@@ -11,6 +12,8 @@ export class MessageBuilderFactory extends BaseMessageBuilderFactory {
     switch (type) {
       case MessageStandardType.EIP191:
         return new Eip191MessageBuilder(this.coinConfig);
+      case MessageStandardType.EIP712:
+        return new Eip712MessageBuilder(this.coinConfig);
       default:
         throw new Error(`Invalid message standard ${type}`);
     }

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

@@ -0,0 +1,125 @@
+import { MessageStandardType, serializeSignatures } from '@bitgo/sdk-core';
+import { coins } from '@bitgo/statics';
+import { MessageBuilderFactory } from '../../../src';
+import should from 'should';
+import { MessageBuildingTestConfig } from './abstractEthMessageTestTypes';
+
+const coinConfig = coins.get('eth');
+
+export function testEthMessageBuilding(testConfig: MessageBuildingTestConfig): void {
+  const { messageType, messageBuilderClass, messageClass, test } = testConfig;
+
+  describe(`${messageType} - Build Method`, () => {
+    const factory = new MessageBuilderFactory(coinConfig);
+    const { payload, metadata, signature, signer } = test.input;
+
+    it('should initialize with the correct message type', () => {
+      const builder = factory.getMessageBuilder(messageType);
+      builder.should.be.instanceof(messageBuilderClass);
+    });
+
+    it('should build a valid message', async () => {
+      const builder = factory.getMessageBuilder(messageType);
+      builder.setPayload(payload).setMetadata(metadata || {});
+
+      const builtMessage = await builder.build();
+      builtMessage.getType().should.equal(messageType);
+      builtMessage.getPayload().should.equal(payload);
+
+      if (metadata) {
+        should.deepEqual(builtMessage.getMetadata(), metadata);
+      } else {
+        should.deepEqual(builtMessage.getMetadata(), {});
+      }
+    });
+
+    it('should throw an error when building without setting the payload', async () => {
+      const builder = factory.getMessageBuilder(messageType);
+      await builder.build().should.be.rejectedWith('Message payload must be set before building the message');
+    });
+
+    it('should include signers when building a message', async () => {
+      const builder = factory.getMessageBuilder(messageType);
+      builder.setPayload(payload);
+      builder.addSigner(signer);
+
+      const message = await builder.build();
+      message.getSigners().should.containEql(signer);
+    });
+
+    it('should include signatures when building a message', async () => {
+      const builder = factory.getMessageBuilder(messageType);
+      builder.setPayload(payload);
+      builder.addSignature(signature);
+
+      const message = await builder.build();
+      message.getSignatures().should.containEql(signature);
+    });
+
+    it('should override metadata.encoding with utf8', async () => {
+      const builder = factory.getMessageBuilder(messageType);
+      builder.setPayload(payload);
+      builder.setMetadata({ encoding: 'hex', customData: 'test data' });
+
+      const message = await builder.build();
+      const metadata = message.getMetadata();
+      should(metadata).not.be.undefined();
+      should(metadata).have.property('encoding', 'utf8');
+      should(metadata).have.property('customData', 'test data');
+    });
+  });
+
+  describe(`${messageType} - From Broadcast Format`, () => {
+    const factory = new MessageBuilderFactory(coinConfig);
+    const { payload, signature, signer, metadata } = test.input;
+
+    const broadcastMessage = {
+      payload,
+      type: messageType,
+      serializedSignatures: serializeSignatures([signature]),
+      signers: [signer],
+      metadata: metadata,
+    };
+
+    it('should reconstruct a message from broadcast format', async () => {
+      const builder = factory.getMessageBuilder(messageType);
+      const message = await builder.fromBroadcastFormat(broadcastMessage);
+
+      message.getType().should.equal(messageType);
+      message.getPayload().should.equal(payload);
+      message.getSignatures().should.containEql(signature);
+      message.getSigners().should.containEql(signer);
+      message.should.be.instanceof(messageClass);
+
+      if (metadata) {
+        should.deepEqual(message.getMetadata(), metadata);
+      } else {
+        should.deepEqual(message.getMetadata(), {});
+      }
+    });
+
+    it('should throw an error for incorrect message type', async () => {
+      const builder = factory.getMessageBuilder(messageType);
+      const broadcastMessageWrongType = { ...broadcastMessage, type: MessageStandardType.UNKNOWN };
+      await builder
+        .fromBroadcastFormat(broadcastMessageWrongType)
+        .should.be.rejectedWith(`Invalid message type, expected ${messageType}`);
+    });
+  });
+
+  describe(`${messageType} - From Broadcast String`, () => {
+    const { payload, signature, signer } = test.input;
+    const broadcastHex = test.broadcastHex;
+
+    it('should parse broadcastable string and return correct builder type', async () => {
+      const factory = new MessageBuilderFactory(coinConfig);
+      const builder = factory.fromBroadcastString(broadcastHex);
+      const message = await builder.build();
+
+      message.getType().should.equal(messageType);
+      message.getPayload().should.equal(payload);
+      message.getSignatures().should.containEql(signature);
+      message.getSigners().should.containEql(signer);
+    });
+  });
+}

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

@@ -0,0 +1,42 @@
+import {
+  BaseMessage,
+  BaseMessageBuilder,
+  MessageMetadata,
+  MessageOptions,
+  MessageStandardType,
+  Signature,
+} from '@bitgo/sdk-core';
+
+type MessageCtor = new (options: MessageOptions) => BaseMessage;
+
+type MessageBuildParams = { payload: string; metadata?: MessageMetadata };
+type SignatureParams = { signature: Signature; signer: string };
+
+type MessageVerificationParams = { expectedSignableHex: string };
+type MessageVerificationParamsBase64 = { expectedSignableBase64: string };
+
+type MessageTestCase = { input: MessageBuildParams; expected: MessageVerificationParams };
+type SignedMessageTestCase = {
+  input: MessageBuildParams & SignatureParams;
+  expected: MessageVerificationParams & MessageVerificationParamsBase64;
+};
+
+type MessageBuilderTestCase = {
+  input: MessageBuildParams & SignatureParams;
+  expected: MessageVerificationParams;
+  broadcastHex: string;
+};
+
+export type MessageTestConfig = {
+  messageType: MessageStandardType;
+  messageClass: MessageCtor;
+  tests: Record<string, MessageTestCase>;
+  signedTest: SignedMessageTestCase;
+};
+
+export type MessageBuildingTestConfig = {
+  messageType: MessageStandardType;
+  messageBuilderClass: typeof BaseMessageBuilder;
+  messageClass: typeof BaseMessage;
+  test: MessageBuilderTestCase;
+};

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

@@ -0,0 +1,143 @@
+import { serializeSignatures } from '@bitgo/sdk-core';
+import { coins } from '@bitgo/statics';
+import should from 'should';
+import { MessageTestConfig } from './abstractEthMessageTestTypes';
+
+const coinConfig = coins.get('eth');
+
+export function testEthMessageSigning(testConfig: MessageTestConfig): void {
+  const { messageType, messageClass, tests, signedTest } = testConfig;
+
+  describe(`${messageType} - Message Type`, () => {
+    it('should have the correct message type', () => {
+      const msgInstance = new messageClass({
+        ...signedTest.input,
+        coinConfig,
+      });
+      msgInstance.getType().should.equal(messageType);
+    });
+  });
+
+  describe(`${messageType} - Signable Payload Generation`, () => {
+    Object.entries(tests).map(([key, { input, expected }]) => {
+      it(`should generate the correct signable payload for message '${key}'`, async () => {
+        const message = new messageClass({
+          ...input,
+          coinConfig,
+        });
+
+        const signablePayload = await message.getSignablePayload();
+        signablePayload.toString('hex').should.equal(expected.expectedSignableHex);
+
+        if (input.metadata) {
+          should.deepEqual(message.getMetadata(), input.metadata);
+        } else {
+          should.deepEqual(message.getMetadata(), {});
+        }
+      });
+    });
+  });
+
+  describe(`${messageType} - Maintaining Signers and Signatures`, () => {
+    const { payload, signature, signer } = signedTest.input;
+
+    it('should be created with the correct signatures and signers', () => {
+      const message = new messageClass({
+        coinConfig,
+        payload,
+        signatures: [signature],
+        signers: [signer],
+      });
+
+      message.getSignatures().should.containEql(signature);
+      message.getSigners().should.containEql(signer);
+    });
+
+    it('should maintain signatures and signers correctly', () => {
+      const message = new messageClass({
+        coinConfig,
+        payload,
+        signatures: [signature],
+        signers: [signer],
+      });
+
+      message.addSignature({
+        publicKey: { pub: 'pub1' },
+        signature: Buffer.from('new-signature'),
+      });
+      message.addSigner('new-signer');
+
+      message.getSignatures().should.containEql({
+        publicKey: { pub: 'pub1' },
+        signature: Buffer.from('new-signature'),
+      });
+      message.getSigners().should.containEql('new-signer');
+
+      // Test replacing all
+      message.setSignatures([
+        {
+          publicKey: { pub: 'pub2' },
+          signature: Buffer.from('replaced-signature'),
+        },
+      ]);
+      message.setSigners(['replaced-signer']);
+
+      message.getSignatures().should.deepEqual([
+        {
+          publicKey: { pub: 'pub2' },
+          signature: Buffer.from('replaced-signature'),
+        },
+      ]);
+      message.getSigners().should.deepEqual(['replaced-signer']);
+    });
+  });
+
+  describe(`${messageType} - Broadcast Format`, () => {
+    const { payload, signature, signer } = signedTest.input;
+    const { expectedSignableBase64 } = signedTest.expected;
+
+    it('should convert to broadcast format correctly', async () => {
+      const message = new messageClass({
+        coinConfig,
+        payload,
+        signatures: [signature],
+        signers: [signer],
+      });
+
+      const broadcastFormat = await message.toBroadcastFormat();
+      const expectedSerializedSignatures = serializeSignatures([signature]);
+
+      broadcastFormat.type.should.equal(messageType);
+      broadcastFormat.payload.should.equal(message.getPayload());
+      broadcastFormat.serializedSignatures?.should.deepEqual(expectedSerializedSignatures);
+      broadcastFormat.signers?.should.deepEqual([signer]);
+      broadcastFormat.signablePayload?.should.equal(expectedSignableBase64);
+
+      if (broadcastFormat.metadata) {
+        broadcastFormat.metadata.should.deepEqual(message.getMetadata());
+      } else {
+        should.deepEqual(message.getMetadata(), {});
+      }
+    });
+
+    it('should convert to broadcast string correctly', async () => {
+      const message = new messageClass({
+        coinConfig,
+        payload,
+        signatures: [signature],
+        signers: [signer],
+      });
+
+      const broadcastHex = await message.toBroadcastString();
+      const broadcastString = Buffer.from(broadcastHex, 'hex').toString();
+      const parsedBroadcast = JSON.parse(broadcastString);
+      const expectedSerializedSignatures = serializeSignatures([signature]);
+
+      parsedBroadcast.type.should.equal(messageType);
+      parsedBroadcast.payload.should.equal(message.getPayload());
+      parsedBroadcast.serializedSignatures.should.deepEqual(expectedSerializedSignatures);
+      parsedBroadcast.signers.should.deepEqual([signer]);
+      parsedBroadcast.metadata.should.deepEqual(message.getMetadata());
+    });
+  });
+}