refactor: we should expect one output for each data instead of an array of data outputs

packages/hathor-rpc-handler/__tests__/rpcMethods/sendNanoContractTx.test.ts

@@ -68,7 +68,7 @@ describe('sendNanoContractTx', () => {
     const expectedActions = [
       {
         ...(rpcRequest.params.actions[0] as unknown as NanoContractActionWithStringAmount),
-        amount: BigInt(100), // Expected conversion to BigInt
+        amount: 100n, // Expected conversion to BigInt
       }
     ];
 
@@ -147,11 +147,11 @@ describe('sendNanoContractTx', () => {
     const expectedActions = [
       {
         ...stringActions[0],
-        amount: BigInt(100),
+        amount: 100n,
       },
       {
         ...stringActions[1],
-        amount: BigInt(200),
+        amount: 200n,
       },
     ];
 
@@ -268,7 +268,7 @@ describe('sendNanoContractTx', () => {
       args: rpcRequest.params.args,
       actions: [{
         ...originalAction,
-        amount: BigInt(100), // Convert amount to BigInt
+        amount: 100n, // Convert amount to BigInt
       }],
     };
 

packages/hathor-rpc-handler/__tests__/rpcMethods/sendTransaction.test.ts

@@ -57,10 +57,15 @@ describe('sendTransaction', () => {
           inputs: [{
             txId: 'testTxId',
             index: 0,
-            value: 100,
+            value: 100n,
             address: 'testAddress',
             token: '00',
           }],
+          outputs: [{
+            address: 'testAddress',
+            value: BigInt(100),
+            token: '00',
+          }],
         }),
         run: sendTransactionMock,
       }),
@@ -104,13 +109,13 @@ describe('sendTransaction', () => {
       data: {
         outputs: [{
           address: 'testAddress',
-          value: BigInt(100),
+          value: 100n,
           token: '00',
         }],
         inputs: [{
           txId: 'testTxId',
           index: 0,
-          value: 100,
+          value: 100n,
           address: 'testAddress',
           token: '00',
         }],
@@ -127,7 +132,7 @@ describe('sendTransaction', () => {
     rpcRequest.params.outputs = [{
       type: 'data',
       value: '100',
-      data: ['test data'],
+      data: 'test data',
     }];
 
     promptHandler
@@ -147,15 +152,75 @@ describe('sendTransaction', () => {
     // Verify data output was transformed correctly
     expect(wallet.sendManyOutputsSendTransaction).toHaveBeenCalledWith(
       expect.arrayContaining([
+        expect.objectContaining({
+          type: 'data',
+          value: 1n,
+          token: '00',
+          data: 'test data',
+        }),
+      ]),
+      expect.any(Object),
+    );
+  });
+
+  it('should handle mix of data and regular outputs correctly', async () => {
+    rpcRequest.params.outputs = [
+      {
+        address: 'testAddress1',
+        value: '100',
+        token: '00',
+      },
+      {
+        type: 'data',
+        data: 'data item',
+        value: '1',
+      },
+      {
+        address: 'testAddress2',
+        value: '200',
+        token: '00',
+      }
+    ];
+
+    promptHandler
+      .mockResolvedValueOnce({
+        type: TriggerResponseTypes.SendTransactionConfirmationResponse,
+        data: { accepted: true },
+      })
+      .mockResolvedValueOnce({
+        type: TriggerResponseTypes.PinRequestResponse,
+        data: { accepted: true, pinCode: '1234' },
+      });
+
+    sendTransactionMock.mockResolvedValue({ hash: 'txHash123' });
+
+    await sendTransaction(rpcRequest, wallet, {}, promptHandler);
+
+    // Verify the transformation preserves regular outputs and handles data output
+    expect(wallet.sendManyOutputsSendTransaction).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({
+          address: 'testAddress1',
+          value: BigInt(100),
+          token: '00',
+        }),
         expect.objectContaining({
           type: 'data',
           value: BigInt(1),
           token: '00',
-          data: ['test data'],
+          data: 'data item',
+        }),
+        expect.objectContaining({
+          address: 'testAddress2',
+          value: BigInt(200),
+          token: '00',
         }),
       ]),
       expect.any(Object),
     );
+
+    // Verify the array length matches the expected number of outputs (2 regular + 1 data output)
+    expect(wallet.sendManyOutputsSendTransaction.mock.calls[0][0]).toHaveLength(3);
   });
 
   it('should throw InvalidParamsError for invalid request parameters', async () => {

packages/hathor-rpc-handler/src/rpcMethods/sendTransaction.ts

@@ -42,7 +42,7 @@ const sendTransactionSchema = z.object({
         .optional(),
       token: z.string().optional(),
       type: z.string().optional(),
-      data: z.array(z.string()).optional(),
+      data: z.string().optional(),
     })
     .transform(output => {
       // If data is present, automatically set type to 'data'
@@ -58,7 +58,7 @@ const sendTransactionSchema = z.object({
       }
       return true;
     }, {
-      message: "Value is required when data is not provided"
+      message: 'Value is required when data is not provided'
     })).min(1),
     inputs: z.array(z.object({
       txId: z.string(),
@@ -100,16 +100,27 @@ export async function sendTransaction(
   validateNetwork(wallet, params.network);
 
   // Transform outputs before sending to wallet-lib
-  const transformedOutputs = params.outputs.map(output => {
+  const transformedOutputs = params.outputs.reduce<Array<{
+    address?: string;
+    value?: bigint;
+    token?: string;
+    type?: string;
+    data?: string;
+  }>>((acc, output) => {
     const result = { ...output };
 
-    if (result.type === 'data' || (result.data && result.data.length > 0)) {
-      result.value = BigInt(1);
-      result.token = constants.NATIVE_TOKEN_UID;
+    // We should manually set the 0.01 HTR to data output
+    // so it's displayed to the user during confirmation.
+    if (result.type === 'data') {
+      return [...acc, {
+        ...output,
+        value: 1n,
+        token: constants.NATIVE_TOKEN_UID,
+      }];
     }
 
-    return result;
-  });
+    return [...acc, result];
+  }, []);
 
   // sendManyOutputsSendTransaction throws if it doesn't receive a pin,
   // but doesn't use it until prepareTxData is called, so we can just assign
@@ -142,13 +153,7 @@ export async function sendTransaction(
     type: TriggerTypes.SendTransactionConfirmationPrompt,
     method: rpcRequest.method,
     data: {
-      outputs: params.outputs as unknown as Array<{
-        address?: string;
-        value: number;
-        token?: string;
-        type?: string;
-        data?: string[];
-      }>,
+      outputs: preparedTx.outputs,
       inputs: preparedTx.inputs,
       changeAddress: params.changeAddress,
     }

packages/hathor-rpc-handler/src/types/rpcRequest.ts

@@ -114,7 +114,7 @@ export interface SendTransactionRpcRequest {
       value: string | number | bigint;
       token?: string;
       type?: string;
-      data?: string[];
+      data?: string;
     }>;
     inputs?: Array<{
       txId: string;