feat(sdk-core): handle TSS EDDSA message signing

TICKET: COIN-4820

Author: bhavidhingra

modules/bitgo/test/v2/unit/internal/tssUtils/common.ts

@@ -1,4 +1,4 @@
-import { ExchangeCommitmentResponse, SignatureShareRecord } from '@bitgo/sdk-core';
+import { ExchangeCommitmentResponse, RequestType, SignatureShareRecord } from '@bitgo/sdk-core';
 import * as nock from 'nock';
 import * as _ from 'lodash';
 
@@ -19,10 +19,14 @@ export async function nockSendSignatureShare(
     signatureShare: unknown;
     signerShare?: string;
     tssType?: 'eddsa' | 'ecdsa';
+    requestType?: RequestType;
+    apiMode?: 'lite' | 'full';
   },
   status = 200
 ): Promise<nock.Scope> {
-  const transactions = getRoute(params.tssType);
+  params.requestType = params.requestType || RequestType.tx;
+  params.apiMode = params.apiMode || 'lite';
+  const transactions = getRoute(params.tssType, params.requestType, params.apiMode);
   return nock('https://bitgo.fakeurl')
     .persist(true)
     .post(`/api/v2/wallet/${params.walletId}/txrequests/${params.txRequestId + transactions}/signatureshares`)
@@ -97,10 +101,22 @@ export async function nockExchangeCommitments(params: {
     .reply(200, params.response);
 }
 
-export function getRoute(tssType: 'eddsa' | 'ecdsa' = 'eddsa'): string {
-  if (tssType === 'ecdsa') {
-    return '/transactions/0';
+export function getRoute(
+  tssType: 'eddsa' | 'ecdsa' = 'eddsa',
+  requestType: RequestType = RequestType.tx,
+  apiMode: 'full' | 'lite' = 'lite'
+): string {
+  switch (requestType) {
+    case RequestType.tx:
+      if (tssType === 'ecdsa' || apiMode === 'full') {
+        return '/transactions/0';
+      }
+      break;
+    case RequestType.message:
+      if (tssType === 'ecdsa' || apiMode === 'full') {
+        return '/messages/0';
+      }
+      break;
   }
-
   return '';
 }

modules/bitgo/test/v2/unit/internal/tssUtils/eddsa.ts

@@ -6,34 +6,35 @@ import * as should from 'should';
 import * as sinon from 'sinon';
 
 import { TestableBG, TestBitGo } from '@bitgo/sdk-test';
-import { BitGo } from '../../../../../src/bitgo';
+import { BitGo } from '../../../../../src';
 import {
+  BaseCoin,
+  CommitmentShareRecord,
+  CommitmentType,
   common,
+  createSharedDataProof,
+  Ed25519BIP32,
+  Eddsa,
+  EncryptedSignerShareType,
+  ExchangeCommitmentResponse,
   Keychain,
+  KeyShare,
   RequestTracer,
+  RequestType,
   SignatureShareRecord,
   SignatureShareType,
   TssUtils,
   TxRequest,
   Wallet,
-  Eddsa,
-  KeyShare,
-  Ed25519BIP32,
-  createSharedDataProof,
-  CommitmentShareRecord,
-  CommitmentType,
-  ExchangeCommitmentResponse,
-  EncryptedSignerShareType,
-  BaseCoin,
 } from '@bitgo/sdk-core';
 import { createWalletSignatures } from '../../tss/helpers';
 import {
-  nockSendSignatureShare,
-  nockGetTxRequest,
   nockCreateTxRequest,
   nockDeleteSignatureShare,
-  nockSendTxRequest,
   nockExchangeCommitments,
+  nockGetTxRequest,
+  nockSendSignatureShare,
+  nockSendTxRequest,
 } from './common';
 
 openpgp.config.rejectCurves = new Set();
@@ -724,6 +725,113 @@ describe('TSS Utils:', async function () {
     });
   });
 
+  describe('signTxRequestForMessage:', function () {
+    const txRequestId = 'randomid-abc';
+    const messageRaw = 'hello world';
+    const messageEncoded = Buffer.from(`${messageRaw}`).toString('hex');
+    const bufferToSign = Buffer.from(messageEncoded, 'hex');
+    const txRequest: TxRequest = {
+      txRequestId,
+      transactions: [],
+      messages: [
+        {
+          state: 'pendingSignature',
+          signatureShares: [],
+          messageRaw,
+          messageEncoded,
+          derivationPath: 'm/0',
+        },
+      ],
+      unsignedTxs: [],
+      date: new Date().toISOString(),
+      intent: {
+        intentType: 'payment',
+      },
+      latest: true,
+      state: 'pendingUserSignature',
+      walletType: 'hot',
+      walletId: 'walletId',
+      policiesChecked: true,
+      version: 1,
+      userId: 'userId',
+      apiVersion: 'full',
+    };
+
+    beforeEach(async function () {
+      const rShare = validUserSignShare.rShares[3];
+      const signatureShare: SignatureShareRecord = {
+        from: SignatureShareType.USER,
+        to: SignatureShareType.BITGO,
+        share: rShare.r + rShare.R,
+      };
+
+      await nockSendSignatureShare({
+        walletId: wallet.id(),
+        txRequestId: txRequest.txRequestId,
+        signatureShare,
+        requestType: RequestType.message,
+        apiMode: 'full',
+      });
+
+      const signatureShare2: SignatureShareRecord = {
+        from: SignatureShareType.BITGO,
+        to: SignatureShareType.USER,
+        share: validBitgoToUserSignShare.rShares[1].r + validBitgoToUserSignShare.rShares[1].R,
+      };
+      txRequest.messages![0].signatureShares.push(signatureShare2);
+      const response = { txRequests: [{ ...txRequest, apiVersion: 'full' }] };
+      await nockGetTxRequest({ walletId: wallet.id(), txRequestId: txRequest.txRequestId, response });
+
+      const bitgoToUserCommitmentShare: CommitmentShareRecord = {
+        from: SignatureShareType.BITGO,
+        to: SignatureShareType.USER,
+        type: CommitmentType.COMMITMENT,
+        share: validBitgoToUserSignShare.rShares[1].commitment,
+      };
+      const exchangeCommitResponse: ExchangeCommitmentResponse = { commitmentShare: bitgoToUserCommitmentShare };
+      await nockExchangeCommitments({
+        walletId: wallet.id(),
+        txRequestId: txRequest.txRequestId,
+        response: exchangeCommitResponse,
+        apiMode: 'full',
+      });
+    });
+
+    afterEach(async function () {
+      txRequest.messages![0].signatureShares = [];
+    });
+
+    it('signTxRequest should succeed with txRequest object as input', async function () {
+      const signedTxRequest = await tssUtils.signTxRequestForMessage({
+        messageRaw,
+        bufferToSign,
+        txRequest,
+        prv: JSON.stringify(validUserSigningMaterial),
+        reqId,
+      });
+      signedTxRequest.messages!.should.deepEqual(txRequest.messages);
+
+      sandbox.verifyAndRestore();
+    });
+
+    it('signTxRequest should succeed with txRequest id as input', async function () {
+      const getTxRequest = sandbox.stub(tssUtils, 'getTxRequest');
+      getTxRequest.resolves(txRequest);
+      getTxRequest.calledWith(txRequestId);
+
+      const signedTxRequest = await tssUtils.signTxRequestForMessage({
+        txRequest: txRequestId,
+        prv: JSON.stringify(validUserSigningMaterial),
+        reqId,
+        messageRaw,
+        bufferToSign,
+      });
+      signedTxRequest.messages!.should.deepEqual(txRequest.messages);
+
+      sandbox.verifyAndRestore();
+    });
+  });
+
   describe('prebuildTxWithIntent:', async function () {
     it('should build single recipient tx', async function () {
       const nockedCreateTx = await nockCreateTxRequest({

modules/sdk-core/src/bitgo/tss/eddsa/eddsa.ts

@@ -130,6 +130,7 @@ export async function createUserSignShare(signablePayload: Buffer, pShare: PShar
  * @param {SignShare} userSignShare - the User Sign Share
  * @param {SignatureShareRecord} bitgoToUserRShare - the Bitgo to User RShare
  * @param {YShare} backupToUserYShare - the backup key Y share received during wallet creation
+ * @param {YShare} bitgoToUserYShare - the Bitgo to User YShare
  * @param {Buffer} signablePayload - the signable payload from a tx
  * @param {CommitmentShareRecord} [bitgoToUserCommitment] - the Bitgo to User Commitment
  * @returns {Promise<GShare>} - the User to Bitgo GShare
@@ -193,8 +194,10 @@ export async function createUserToBitGoGShare(
  * @param {String} txRequestId - the txRequest Id
  * @param {SignShare} userSignShare - the user Sign Share
  * @param {String} encryptedSignerShare - signer share encrypted to bitgo key
+ * @param {String} apiMode - the api mode, defaults to 'lite'
  * @returns {Promise<void>}
  * @param {IRequestTracer} reqId - the request tracer request id
+ * @param {RequestType} requestType - the request type, defaults to RequestType.tx
  */
 export async function offerUserToBitgoRShare(
   bitgo: BitGoBase,
@@ -203,7 +206,8 @@ export async function offerUserToBitgoRShare(
   userSignShare: SignShare,
   encryptedSignerShare: string,
   apiMode: 'full' | 'lite' = 'lite',
-  reqId?: IRequestTracer
+  reqId?: IRequestTracer,
+  requestType: RequestType = RequestType.tx
 ): Promise<void> {
   const rShare: RShare = userSignShare.rShares[ShareKeyPosition.BITGO];
   if (_.isNil(rShare)) {
@@ -218,13 +222,12 @@ export async function offerUserToBitgoRShare(
     share: rShare.r + rShare.R,
   };
 
-  // TODO (BG-57944): implement message signing for EDDSA
   await sendSignatureShare(
     bitgo,
     walletId,
     txRequestId,
     signatureShare,
-    RequestType.tx,
+    requestType,
     encryptedSignerShare,
     'eddsa',
     apiMode,
@@ -240,19 +243,26 @@ export async function offerUserToBitgoRShare(
  * @param {String} walletId - the wallet id
  * @param {String} txRequestId - the txRequest Id
  * @param {IRequestTracer} reqId - the request tracer request id
+ * @param {RequestType} requestType - the request type, defaults to RequestType.tx
  * @returns {Promise<SignatureShareRecord>} - a Signature Share
  */
 export async function getBitgoToUserRShare(
   bitgo: BitGoBase,
   walletId: string,
   txRequestId: string,
-  reqId?: IRequestTracer
+  reqId?: IRequestTracer,
+  requestType: RequestType = RequestType.tx
 ): Promise<SignatureShareRecord> {
   const txRequest = await getTxRequest(bitgo, walletId, txRequestId, reqId);
   let signatureShares;
   if (txRequest.apiVersion === 'full') {
-    assert(txRequest.transactions, 'transactions required as part of txRequest');
-    signatureShares = txRequest.transactions[0].signatureShares;
+    if (requestType === RequestType.tx) {
+      assert(txRequest.transactions, 'transactions required as part of txRequest');
+      signatureShares = txRequest.transactions[0].signatureShares;
+    } else if (requestType === RequestType.message) {
+      assert(txRequest.messages, 'messages required as part of txRequest');
+      signatureShares = txRequest.messages[0].signatureShares;
+    }
   } else {
     signatureShares = txRequest.signatureShares;
   }
@@ -276,7 +286,9 @@ export async function getBitgoToUserRShare(
  * @param {String} walletId - the wallet id
  * @param {String} txRequestId - the txRequest Id
  * @param {GShare} userToBitgoGShare - the User to Bitgo GShare
+ * @param {String} apiMode - the api mode, defaults to 'lite'
  * @param {IRequestTracer} reqId - the request tracer request id
+ * @param {RequestType} requestType - the request type, defaults to RequestType.tx
  * @returns {Promise<void>}
  */
 export async function sendUserToBitgoGShare(
@@ -285,7 +297,8 @@ export async function sendUserToBitgoGShare(
   txRequestId: string,
   userToBitgoGShare: GShare,
   apiMode: 'full' | 'lite' = 'lite',
-  reqId?: IRequestTracer
+  reqId?: IRequestTracer,
+  requestType: RequestType = RequestType.tx
 ): Promise<void> {
   if (userToBitgoGShare.i !== ShareKeyPosition.USER) {
     throw new Error('Invalid GShare, doesnt belong to the User');
@@ -296,13 +309,12 @@ export async function sendUserToBitgoGShare(
     share: userToBitgoGShare.R + userToBitgoGShare.gamma,
   };
 
-  // TODO (BG-57944): implement message signing for EDDSA
   await sendSignatureShare(
     bitgo,
     walletId,
     txRequestId,
     signatureShare,
-    RequestType.tx,
+    requestType,
     undefined,
     'eddsa',
     apiMode,

modules/sdk-core/src/bitgo/utils/tss/baseTypes.ts

@@ -355,9 +355,12 @@ export type TxRequest = {
     signatureShares: SignatureShareRecord[];
     messageRaw: string;
     messageEncoded?: string;
+    messageBroadcastable?: string;
+    messageStandardType?: MessageStandardType;
     derivationPath: string;
     combineSigShare?: string;
     txHash?: string;
+    commitmentShares?: CommitmentShareRecord[];
   }[];
   apiVersion?: TxRequestVersion;
   latest: boolean;