Use input as data in eth_sendTransaction

src/wallet.test.ts

@@ -117,6 +117,109 @@ describe('wallet', () => {
       );
     });
 
+    it('processes transaction with data field but without input field', async () => {
+      const { engine } = createTestSetup();
+      const getAccounts = async () => testAddresses.slice(0, 2);
+      const witnessedTxParams: TransactionParams[] = [];
+      const processTransaction = async (_txParams: TransactionParams) => {
+        witnessedTxParams.push(_txParams);
+        return testTxHash;
+      };
+      engine.push(createWalletMiddleware({ getAccounts, processTransaction }));
+      const txParams = {
+        from: testAddresses[0],
+        data: '0x0',
+      };
+
+      const payload = { method: 'eth_sendTransaction', params: [txParams] };
+      const sendTxResponse = await pify(engine.handle).call(engine, payload);
+      const sendTxResult = sendTxResponse.result;
+      expect(sendTxResult).toBeDefined();
+      expect(sendTxResult).toStrictEqual(testTxHash);
+      expect(witnessedTxParams).toHaveLength(1);
+      expect(witnessedTxParams[0]).toStrictEqual({
+        from: testAddresses[0],
+        data: '0x0',
+        input: '0x0',
+      });
+    });
+
+    it('processes transaction with input field but without data field', async () => {
+      const { engine } = createTestSetup();
+      const getAccounts = async () => testAddresses.slice(0, 2);
+      const witnessedTxParams: TransactionParams[] = [];
+      const processTransaction = async (_txParams: TransactionParams) => {
+        witnessedTxParams.push(_txParams);
+        return testTxHash;
+      };
+      engine.push(createWalletMiddleware({ getAccounts, processTransaction }));
+      const txParams = {
+        from: testAddresses[0],
+        input: '0x0',
+      };
+
+      const payload = { method: 'eth_sendTransaction', params: [txParams] };
+      const sendTxResponse = await pify(engine.handle).call(engine, payload);
+      const sendTxResult = sendTxResponse.result;
+      expect(sendTxResult).toBeDefined();
+      expect(sendTxResult).toStrictEqual(testTxHash);
+      expect(witnessedTxParams).toHaveLength(1);
+      expect(witnessedTxParams[0]).toStrictEqual({
+        from: testAddresses[0],
+        data: '0x0',
+        input: '0x0',
+      });
+    });
+
+    it('processes transaction with matching input and data field', async () => {
+      const { engine } = createTestSetup();
+      const getAccounts = async () => testAddresses.slice(0, 2);
+      const witnessedTxParams: TransactionParams[] = [];
+      const processTransaction = async (_txParams: TransactionParams) => {
+        witnessedTxParams.push(_txParams);
+        return testTxHash;
+      };
+      engine.push(createWalletMiddleware({ getAccounts, processTransaction }));
+      const txParams = {
+        from: testAddresses[0],
+        data: '0x0',
+        input: '0x0',
+      };
+
+      const payload = { method: 'eth_sendTransaction', params: [txParams] };
+      const sendTxResponse = await pify(engine.handle).call(engine, payload);
+      const sendTxResult = sendTxResponse.result;
+      expect(sendTxResult).toBeDefined();
+      expect(sendTxResult).toStrictEqual(testTxHash);
+      expect(witnessedTxParams).toHaveLength(1);
+      expect(witnessedTxParams[0]).toStrictEqual({
+        from: testAddresses[0],
+        data: '0x0',
+        input: '0x0',
+      });
+    });
+
+    it('throws when input and data fields are both defined but do not match', async () => {
+      const { engine } = createTestSetup();
+      const getAccounts = async () => testAddresses.slice(0, 2);
+      const witnessedTxParams: TransactionParams[] = [];
+      const processTransaction = async (_txParams: TransactionParams) => {
+        witnessedTxParams.push(_txParams);
+        return testTxHash;
+      };
+      engine.push(createWalletMiddleware({ getAccounts, processTransaction }));
+      const txParams = {
+        from: testAddresses[0],
+        data: '0x0',
+        input: '0x1',
+      };
+
+      const payload = { method: 'eth_sendTransaction', params: [txParams] };
+      await expect(pify(engine.handle).call(engine, payload)).rejects.toThrow(
+        new Error('Invalid input.'),
+      );
+    });
+
     it('should not override other request params', async () => {
       const { engine } = createTestSetup();
       const getAccounts = async () => testAddresses.slice(0, 2);
@@ -129,6 +232,8 @@ describe('wallet', () => {
       const txParams = {
         from: testAddresses[0],
         to: testAddresses[1],
+        data: '0x0',
+        input: '0x0',
       };
 
       const payload = { method: 'eth_sendTransaction', params: [txParams] };

src/wallet.ts

@@ -159,10 +159,25 @@
       throw rpcErrors.invalidInput();
     }
 
-    const params = req.params[0] as TransactionParams | undefined;
-    const txParams: TransactionParams = {
-      ...params,
-      from: await validateAndNormalizeKeyholder(params?.from || '', req),
+    const params = req.params[0] as
+      | (TransactionParams & {
+          input?: string;
+          data?: string;
+        })
+      | undefined;
+
+    const { from, data, input, ...restParams } = params || {};
+    if (data && input && data !== input) {
+      throw rpcErrors.invalidInput();
+    }
+
+    const txParamsData = data || input;
+    const txParams: TransactionParams & { data?: string; input?: string } = {
+      ...restParams,
+      ...(txParamsData
+        ? { data: txParamsData, input: txParamsData }
+        : undefined),
+      from: await validateAndNormalizeKeyholder(from || '', req),
     };
     res.result = await processTransaction(txParams, req);
   }
@@ -458,7 +473,7 @@
    *
    * @param address - The address to validate and normalize.
    * @param req - The request object.
    * @returns {string} - The normalized address, if valid. Otherwise, throws
    * an error
    */
   async function validateAndNormalizeKeyholder(