Merge remote-tracking branch 'origin/HSM-850'

Author: islamaminBitGo

modules/abstract-eth/src/lib/iface.ts

@@ -113,6 +113,7 @@ export interface TransferData {
   signature: string;
   tokenContractAddress?: string;
   data?: string;
+  operationHashPrefix?: string;
 }
 
 export interface TokenTransferData extends TransferData {

modules/abstract-eth/src/lib/transaction.ts

@@ -64,15 +64,15 @@ export class Transaction extends BaseTransaction {
    *
    * @param {TxData} txData The transaction data to set
    */
-  setTransactionData(txData: TxData): void {
+  setTransactionData(txData: TxData, isFirstSigner?: boolean): void {
     this._transactionData = EthTransactionData.fromJson(txData, this._common);
-    this.updateFields();
+    this.updateFields(isFirstSigner);
   }
 
   /**
    * Update the internal fields based on the currently set transaction data, if there is any
    */
-  protected updateFields(): void {
+  protected updateFields(isFirstSigner?: boolean): void {
     if (!this._transactionData) {
       return;
     }
@@ -98,7 +98,7 @@ export class Transaction extends BaseTransaction {
       this._type === TransactionType.SendERC721 ||
       this._type === TransactionType.SendERC1155
     ) {
-      const { to, amount, tokenContractAddress, signature } = decodeTransferData(txData.data);
+      const { to, amount, tokenContractAddress, signature } = decodeTransferData(txData.data, isFirstSigner);
       let coinName: string;
       if (tokenContractAddress) {
         const token = getToken(tokenContractAddress, this._coinConfig.network, this._coinConfig.family);
@@ -118,8 +118,9 @@ export class Transaction extends BaseTransaction {
         value: amount,
         coin: coinName,
       });
-
-      this._signatures.push(signature);
+      if (signature !== '0x') {
+        this._signatures.push(signature);
+      }
     }
   }
 

modules/abstract-eth/src/lib/transactionBuilder.ts

@@ -117,8 +117,10 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
 
     this.transaction.setTransactionType(this._type);
     transactionData.from = this._sourceKeyPair ? this._sourceKeyPair.getAddress() : undefined;
-
-    this.transaction.setTransactionData(transactionData);
+    this.transaction.setTransactionData(
+      transactionData,
+      this._transfer ? this._transfer.getIsFirstSigner() : undefined
+    );
     // Build and sign a new transaction based on the latest changes
     if (this._sourceKeyPair && this._sourceKeyPair.getKeys().prv) {
       await this.transaction.sign(this._sourceKeyPair);
@@ -152,11 +154,11 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
   }
 
   /** @inheritdoc */
-  protected fromImplementation(rawTransaction: string): Transaction {
+  protected fromImplementation(rawTransaction: string, isFirstSigner?: boolean): Transaction {
     let tx: Transaction;
     if (/^0x?[0-9a-f]{1,}$/.test(rawTransaction.toLowerCase())) {
       tx = Transaction.fromSerialized(this._coinConfig, this._common, rawTransaction);
-      this.loadBuilderInput(tx.toJson());
+      this.loadBuilderInput(tx.toJson(), isFirstSigner);
     } else {
       const txData = JSON.parse(rawTransaction);
       tx = new Transaction(this._coinConfig, txData);
@@ -168,8 +170,9 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
    * Load the builder data using the deserialized transaction
    *
    * @param {TxData} transactionJson the deserialized transaction json
+   * @param {boolean} isFirstSigner if the transaction is being signed by the first signer
    */
-  protected loadBuilderInput(transactionJson: TxData): void {
+  protected loadBuilderInput(transactionJson: TxData, isFirstSigner?: boolean): void {
     const decodedType = classifyTransaction(transactionJson.data);
     this.type(decodedType);
     this.counter(transactionJson.nonce);
@@ -195,10 +198,14 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
     if (hasSignature(transactionJson)) {
       this._txSignature = { v: transactionJson.v!, r: transactionJson.r!, s: transactionJson.s! };
     }
-    this.setTransactionTypeFields(decodedType, transactionJson);
+    this.setTransactionTypeFields(decodedType, transactionJson, isFirstSigner);
   }
 
-  protected setTransactionTypeFields(decodedType: TransactionType, transactionJson: TxData): void {
+  protected setTransactionTypeFields(
+    decodedType: TransactionType,
+    transactionJson: TxData,
+    isFirstSigner?: boolean
+  ): void {
     switch (decodedType) {
       case TransactionType.WalletInitialization:
         const { owners, salt } = decodeWalletCreationData(transactionJson.data);
@@ -233,7 +240,7 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
       case TransactionType.SendERC1155:
       case TransactionType.SendERC721:
         this.setContract(transactionJson.to);
-        this._transfer = this.transfer(transactionJson.data);
+        this._transfer = this.transfer(transactionJson.data, isFirstSigner);
         break;
       case TransactionType.AddressInitialization:
         this.setContract(transactionJson.to);
@@ -614,7 +621,10 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
    * @param [data] transfer data to initialize the transfer builder with, empty if none given
    * @returns {TransferBuilder | ERC721TransferBuilder | ERC1155TransferBuilder} the transfer builder
    */
-  abstract transfer(data?: string): TransferBuilder | ERC721TransferBuilder | ERC1155TransferBuilder;
+  abstract transfer(
+    data?: string,
+    isFirstSigner?: boolean
+  ): TransferBuilder | ERC721TransferBuilder | ERC1155TransferBuilder;
 
   /**
    * Returns the serialized sendMultiSig contract method data

modules/abstract-eth/src/lib/transferBuilder.ts

@@ -17,14 +17,16 @@ export class TransferBuilder {
   protected _signKey: string | null;
   protected _expirationTime: number;
   protected _signature: string;
+  protected _isFirstSigner: boolean | undefined;
   private _data: string;
   private _tokenContractAddress?: string;
   private _coin: Readonly<BaseCoin>;
   private _chainId?: string;
   private _coinUsesNonPackedEncodingForTxData?: boolean;
   private _walletVersion?: number;
 
-  constructor(serializedData?: string) {
+  constructor(serializedData?: string, isFirstSigner?: boolean) {
+    this._isFirstSigner = isFirstSigner;
     if (serializedData) {
       this.decodeTransferData(serializedData);
     } else {
@@ -51,6 +53,10 @@ export class TransferBuilder {
     return this;
   }
 
+  getIsFirstSigner(): boolean {
+    return this._isFirstSigner ? this._isFirstSigner : false;
+  }
+
   walletVersion(version: number): TransferBuilder {
     this._walletVersion = version;
     return this;
@@ -103,6 +109,11 @@ export class TransferBuilder {
     throw new InvalidParameterValueError('Invalid expiration time');
   }
 
+  isFirstSigner(isFirstSigner: boolean): TransferBuilder {
+    this._isFirstSigner = isFirstSigner;
+    return this;
+  }
+
   tokenContractAddress(tokenContractAddress: string): TransferBuilder {
     this._tokenContractAddress = tokenContractAddress;
     return this;
@@ -127,24 +138,29 @@ export class TransferBuilder {
     this._coinUsesNonPackedEncodingForTxData =
       coinUsesNonPackedEncodingForTxData && this._tokenContractAddress === undefined;
     if (this.hasMandatoryFields()) {
-      if (this._tokenContractAddress !== undefined) {
-        return sendMultiSigTokenData(
-          this._toAddress,
-          this._amount,
-          this._tokenContractAddress,
-          this._expirationTime,
-          this._sequenceId,
-          this.getSignature()
-        );
+      if (this._isFirstSigner) {
+        // First signer signs different data than the second signer in multisig evm contracts.
+        return ethUtil.addHexPrefix(this.getSignatureData().toString('hex'));
       } else {
-        return sendMultiSigData(
-          this._toAddress,
-          this._amount,
-          this._data,
-          this._expirationTime,
-          this._sequenceId,
-          this.getSignature()
-        );
+        if (this._tokenContractAddress !== undefined) {
+          return sendMultiSigTokenData(
+            this._toAddress,
+            this._amount,
+            this._tokenContractAddress,
+            this._expirationTime,
+            this._sequenceId,
+            this.getSignature()
+          );
+        } else {
+          return sendMultiSigData(
+            this._toAddress,
+            this._amount,
+            this._data,
+            this._expirationTime,
+            this._sequenceId,
+            this.getSignature()
+          );
+        }
       }
     }
     throw new BuildTransactionError(
@@ -282,7 +298,7 @@ export class TransferBuilder {
   }
 
   private decodeTransferData(data: string): void {
-    const transferData = decodeTransferData(data);
+    const transferData = decodeTransferData(data, this._isFirstSigner);
 
     this._toAddress = transferData.to;
     this._amount = transferData.amount;

modules/abstract-eth/src/lib/transferBuilders/transferBuilderERC1155.ts

@@ -53,6 +53,10 @@ export class ERC1155TransferBuilder extends BaseNFTTransferBuilder {
     return this;
   }
 
+  getIsFirstSigner(): boolean {
+    return false;
+  }
+
   signAndBuild(chainId: string): string {
     this._chainId = chainId;
     const hasMandatoryFields = this.hasMandatoryFields();

modules/abstract-eth/src/lib/transferBuilders/transferBuilderERC721.ts

@@ -43,6 +43,10 @@ export class ERC721TransferBuilder extends BaseNFTTransferBuilder {
     return this;
   }
 
+  getIsFirstSigner(): boolean {
+    return false;
+  }
+
   build(): string {
     const types = ERC721SafeTransferTypes;
     const values = [this._fromAddress, this._toAddress, this._tokenId, this._bytes];

modules/abstract-eth/src/lib/utils.ts

@@ -71,6 +71,8 @@ import {
   v4CreateForwarderMethodId,
   flushTokensTypesv4,
   flushForwarderTokensMethodIdV4,
+  sendMultiSigTokenTypesFirstSigner,
+  sendMultiSigTypesFirstSigner,
 } from './walletUtil';
 import { EthTransactionData } from './types';
 
@@ -292,11 +294,11 @@ export function decodeWalletCreationData(data: string): WalletInitializationData
  * @param data The data to decode
  * @returns parsed transfer data
  */
-export function decodeTransferData(data: string): TransferData {
+export function decodeTransferData(data: string, isFirstSigner?: boolean): TransferData {
   if (data.startsWith(sendMultisigMethodId)) {
-    return decodeNativeTransferData(data);
+    return decodeNativeTransferData(data, isFirstSigner);
   } else if (data.startsWith(sendMultisigTokenMethodId)) {
-    return decodeTokenTransferData(data);
+    return decodeTokenTransferData(data, isFirstSigner);
   } else {
     throw new BuildTransactionError(`Invalid transfer bytecode: ${data}`);
   }
@@ -306,19 +308,34 @@ export function decodeTransferData(data: string): TransferData {
  * Decode the given ABI-encoded transfer data for the sendMultisigToken function and return parsed fields
  *
  * @param data The data to decode
+ * @param isFirstSigner whether transaction is being built for a first signer
  * @returns parsed token transfer data
  */
-export function decodeTokenTransferData(data: string): TokenTransferData {
+export function decodeTokenTransferData(data: string, isFirstSigner?: boolean): TokenTransferData {
   if (!data.startsWith(sendMultisigTokenMethodId)) {
     throw new BuildTransactionError(`Invalid transfer bytecode: ${data}`);
   }
-
-  const [to, amount, tokenContractAddress, expireTime, sequenceId, signature] = getRawDecoded(
-    sendMultiSigTokenTypes,
-    getBufferedByteCode(sendMultisigTokenMethodId, data)
-  );
+  let to: RecursiveBufferOrString | undefined;
+  let amount: RecursiveBufferOrString | undefined;
+  let tokenContractAddress: RecursiveBufferOrString | undefined;
+  let expireTime: RecursiveBufferOrString | undefined;
+  let sequenceId: RecursiveBufferOrString | undefined;
+  let signature: RecursiveBufferOrString | undefined;
+  let prefix: RecursiveBufferOrString | undefined;
+  if (!isFirstSigner) {
+    [to, amount, tokenContractAddress, expireTime, sequenceId, signature] = getRawDecoded(
+      sendMultiSigTokenTypes,
+      getBufferedByteCode(sendMultisigTokenMethodId, data)
+    );
+  } else {
+    [prefix, to, amount, tokenContractAddress, expireTime, sequenceId] = getRawDecoded(
+      sendMultiSigTokenTypesFirstSigner,
+      getBufferedByteCode(sendMultisigTokenMethodId, data)
+    );
+  }
 
   return {
+    operationHashPrefix: isFirstSigner ? (prefix as string) : undefined,
     to: addHexPrefix(to as string),
     amount: new BigNumber(bufferToHex(amount as Buffer)).toFixed(),
     expireTime: bufferToInt(expireTime as Buffer),
@@ -417,19 +434,35 @@ export function decodeERC1155TransferData(data: string): ERC1155TransferData {
  * Decode the given ABI-encoded transfer data for the sendMultisig function and return parsed fields
  *
  * @param data The data to decode
+ * @param isFirstSigner whether transaction is being built for a first signer
  * @returns parsed transfer data
  */
-export function decodeNativeTransferData(data: string): NativeTransferData {
+export function decodeNativeTransferData(data: string, isFirstSigner?: boolean): NativeTransferData {
   if (!data.startsWith(sendMultisigMethodId)) {
     throw new BuildTransactionError(`Invalid transfer bytecode: ${data}`);
   }
 
-  const [to, amount, internalData, expireTime, sequenceId, signature] = getRawDecoded(
-    sendMultiSigTypes,
-    getBufferedByteCode(sendMultisigMethodId, data)
-  );
+  let to: RecursiveBufferOrString | undefined;
+  let amount: RecursiveBufferOrString | undefined;
+  let internalData: RecursiveBufferOrString | undefined;
+  let expireTime: RecursiveBufferOrString | undefined;
+  let sequenceId: RecursiveBufferOrString | undefined;
+  let signature: RecursiveBufferOrString | undefined;
+  let prefix: RecursiveBufferOrString | undefined;
+  if (!isFirstSigner) {
+    [to, amount, internalData, expireTime, sequenceId, signature] = getRawDecoded(
+      sendMultiSigTypes,
+      getBufferedByteCode(sendMultisigMethodId, data)
+    );
+  } else {
+    [prefix, to, amount, internalData, expireTime, sequenceId] = getRawDecoded(
+      sendMultiSigTypesFirstSigner,
+      getBufferedByteCode(sendMultisigMethodId, data)
+    );
+  }
 
   return {
+    operationHashPrefix: isFirstSigner ? (prefix as string) : undefined,
     to: addHexPrefix(to as string),
     amount: new BigNumber(bufferToHex(amount as Buffer)).toFixed(),
     expireTime: bufferToInt(expireTime as Buffer),

modules/abstract-eth/src/lib/walletUtil.ts

@@ -24,8 +24,10 @@ export const flushTokensTypesv4 = ['address'];
 export const flushCoinsTypes = [];
 
 export const sendMultiSigTypes = ['address', 'uint', 'bytes', 'uint', 'uint', 'bytes'];
+export const sendMultiSigTypesFirstSigner = ['string', 'address', 'uint', 'bytes', 'uint', 'uint'];
 
 export const sendMultiSigTokenTypes = ['address', 'uint', 'address', 'uint', 'uint', 'bytes'];
+export const sendMultiSigTokenTypesFirstSigner = ['string', 'address', 'uint', 'address', 'uint', 'uint'];
 
 export const ERC721SafeTransferTypes = ['address', 'address', 'uint256', 'bytes'];
 

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

@@ -29,7 +29,7 @@ export class TransactionBuilder extends EthLikeTransactionBuilder {
    * @param [data] transfer data to initialize the transfer builder with, empty if none given
    * @returns {TransferBuilder | ERC721TransferBuilder | ERC1155TransferBuilder} the transfer builder
    */
-  transfer(data?: string): TransferBuilder | ERC721TransferBuilder | ERC1155TransferBuilder {
+  transfer(data?: string, isFirstSigner?: boolean): TransferBuilder | ERC721TransferBuilder | ERC1155TransferBuilder {
     if (
       !(
         this._type === TransactionType.Send ||
@@ -40,7 +40,7 @@ export class TransactionBuilder extends EthLikeTransactionBuilder {
       throw new BuildTransactionError('Transfers can only be set for send transactions');
     } else if (!this._transfer) {
       if (this._type === TransactionType.Send) {
-        this._transfer = new TransferBuilder(data);
+        this._transfer = new TransferBuilder(data, isFirstSigner);
       } else if (this._type === TransactionType.SendERC721) {
         this._transfer = new ERC721TransferBuilder(data);
       } else if (this._type === TransactionType.SendERC1155) {

modules/sdk-coin-eth/test/resources/eth.ts

@@ -96,6 +96,9 @@ export const CONTRACT_TOKEN_CUSD_ADDRESS = '0xa561131a1C8aC25925FB848bCa45A74aF6
 export const SEND_TX_BROADCAST_LEGACY =
   '0xf901cc02843b9aca0083b8a1a0948f977e912ef500548a0c3be6ddde9899f1199b8180b901643912521500000000000000000000000019645032c7f1533395d44a629462e751084d3e4c000000000000000000000000000000000000000000000000000000003b9aca0000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000005ec67e28000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000417e522e602252e010f97b81b1a83128cf283dcef2ea06c221a236c1c11883adfc222a46f4c9a6ab8cd1d5dd1e963ffa443de88c9cebf755c399702dc00b0b55d61b000000000000000000000000000000000000000000000000000000000000008284f4a0375b0731252b8a4a6f54cd3ee8078e5ba8a89168c8b9b3a49a7a3fb60984b49fa029de0bb07d891c5ad4273016055e474b0c70fa288008eadfaa16ec73b6b78427';
 
+export const SEND_TX_BROADCAST_RECOVERY =
+  '0x02f9014b824268020a648203e8948f977e912ef500548a0c3be6ddde9899f1199b8180b901253912521500000000000000000000000000000000000000000000000000000000000000c000000000000000000000000019645032c7f1533395d44a629462e751084d3e4c000000000000000000000000000000000000000000000000000000003b9aca000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000005ec67e28000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000054554484552000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0808080';
+
 export const SEND_TX_BROADCAST_EIP1559 = `0x02f901d282426802830f4240840605234083b8a1a0948f977e912ef500548a0c3be6ddde9899f1199b8180b901643912521500000000000000000000000019645032c7f1533395d44a629462e751084d3e4c000000000000000000000000000000000000000000000000000000003b9aca0000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000005ec67e28000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000417e522e602252e010f97b81b1a83128cf283dcef2ea06c221a236c1c11883adfc222a46f4c9a6ab8cd1d5dd1e963ffa443de88c9cebf755c399702dc00b0b55d61b00000000000000000000000000000000000000000000000000000000000000c080a011efa5a61513c91c611ac1ba2ad1ed35ac90b7541f9c2bcc3fad9f14f156ee09a010be91f8e395e9fb9be5b6afbcbe7982691f149a6e5f3fc2ff5db327b03b74e0`;
 
 export const SEND_TX_AMOUNT_ZERO_BROADCAST =