added support for txn >5kB

packages/app-btc/src/operations/signTxn/helpers.ts

@@ -18,6 +18,12 @@ export const assertSignTxnParams = (params: ISignTxnParams) => {
   assert(params.txn.inputs.length > 0, 'txn.inputs should not be empty');
   assert(params.txn.outputs, 'txn.outputs should be defined');
   assert(params.txn.outputs.length > 0, 'txn.outputs should not be empty');
+  assert(params.txn.rawTxn, 'txn.rawTxn should be defined');
+  assert(params.txn.rawTxn.length > 0, 'txn.rawTxn should not be empty');
+  assert(
+    params.txn.inputs.length === params.txn.rawTxn.length,
+    'txn.rawTxn should not be same length as txn.inputs',
+  );
 
   for (let i = 0; i < params.txn.inputs.length; i += 1) {
     const input = params.txn.inputs[i];
@@ -42,13 +48,6 @@ export const assertSignTxnParams = (params: ISignTxnParams) => {
       isHex(input.prevTxnHash),
       `txn.inputs[${i}].prevTxnHash should be valid hex string`,
     );
-
-    if (input.prevTxn) {
-      assert(
-        isHex(input.prevTxn),
-        `txn.inputs[${i}].prevTxn should be valid hex string`,
-      );
-    }
   }
 
   for (let i = 0; i < params.txn.outputs.length; i += 1) {
@@ -65,10 +64,6 @@ export const assertSignTxnParams = (params: ISignTxnParams) => {
         output.chainIndex,
         `txn.outputs[${i}].chainIndex should be define when it's a change output`,
       );
-      assert(
-        output.addressIndex,
-        `txn.outputs[${i}].addressIndex should be define  when it's a change output`,
-      );
     }
   }
 };

packages/app-btc/src/operations/signTxn/index.ts

@@ -62,52 +62,50 @@ export const signTxn = async (
     meta: {
       version: signTxnDefaultParams.version,
       locktime: params.txn.locktime ?? signTxnDefaultParams.locktime,
-      inputSize: params.txn.inputs.length,
-      outputSize: params.txn.inputs.length,
-      hashType: params.txn.hashType ?? signTxnDefaultParams.hashtype,
+      inputCount: params.txn.inputs.length,
+      outputCount: params.txn.outputs.length,
+      sighash: params.txn.hashType ?? signTxnDefaultParams.hashtype,
     },
   });
+  const { metaAccepted } = await helper.waitForResult();
+  assertOrThrowInvalidResult(metaAccepted);
 
   for (let i = 0; i < params.txn.inputs.length; i += 1) {
-    const { input: inputRequest } = await helper.waitForResult();
-    assertOrThrowInvalidResult(inputRequest);
-    assertOrThrowInvalidResult(inputRequest.index === i);
-
     const input = params.txn.inputs[i];
     await helper.sendQuery({
       input: {
-        prevTxn: hexToUint8Array(input.prevTxn),
         prevTxnHash: hexToUint8Array(input.prevTxnHash),
-        prevIndex: input.prevIndex,
+        prevOutputIndex: input.prevIndex,
         scriptPubKey: hexToUint8Array(input.scriptPubKey),
         value: input.value,
         sequence: input.sequence ?? signTxnDefaultParams.input.sequence,
-        chainIndex: input.chainIndex,
+        changeIndex: input.chainIndex,
         addressIndex: input.addressIndex,
       },
     });
+    const { inputAccepted } = await helper.waitForResult();
+    assertOrThrowInvalidResult(inputAccepted);
   }
 
-  for (let i = 0; i < params.txn.outputs.length; i += 1) {
-    const { output: outputRequest } = await helper.waitForResult();
-    assertOrThrowInvalidResult(outputRequest);
-    assertOrThrowInvalidResult(outputRequest.index === i);
+  for (let i = 0; i < params.txn.rawTxn.length; i += 1) {
+    const txnBytes = hexToUint8Array(params.txn.rawTxn[i]);
+    await helper.sendInChunks(txnBytes, 'rawTxn', 'rawTxn');
+  }
 
+  for (let i = 0; i < params.txn.outputs.length; i += 1) {
     const output = params.txn.outputs[i];
     await helper.sendQuery({
       output: {
         scriptPubKey: hexToUint8Array(output.scriptPubKey),
         value: output.value,
         isChange: output.isChange,
-        chainIndex: output.chainIndex,
-        addressIndex: output.addressIndex,
+        changesIndex: output.chainIndex,
       },
     });
+    const { outputAccepted } = await helper.waitForResult();
+    assertOrThrowInvalidResult(outputAccepted);
   }
 
-  const { verified } = await helper.waitForResult();
-  assertOrThrowInvalidResult(verified);
-
   forceStatusUpdate(SignTxnStatus.SIGN_TXN_STATUS_VERIFY);
 
   const signatures: string[] = [];
@@ -122,7 +120,7 @@ export const signTxn = async (
     const { signature } = await helper.waitForResult();
     assertOrThrowInvalidResult(signature);
 
-    signatures.push(uint8ArrayToHex(signature.signature));
+    signatures.push(uint8ArrayToHex(signature.unlockingScript));
   }
 
   forceStatusUpdate(SignTxnStatus.SIGN_TXN_STATUS_CARD);

packages/app-btc/src/operations/signTxn/types.ts

@@ -2,20 +2,18 @@ import { SignTxnStatus } from '../../proto/generated/types';
 
 export type SignTxnEventHandler = (event: SignTxnStatus) => void;
 
-export interface ISignTxnInput {
+export interface ISignTxnInputData {
   prevTxnHash: string;
   prevIndex: number;
   value: string;
   scriptPubKey: string;
 
   chainIndex: number;
   addressIndex: number;
-
-  prevTxn: string;
   sequence?: number;
 }
 
-export interface ISignTxnOutput {
+export interface ISignTxnOutputData {
   value: string;
   scriptPubKey: string;
 
@@ -30,8 +28,9 @@ export interface ISignTxnParams {
   onEvent?: SignTxnEventHandler;
 
   txn: {
-    inputs: ISignTxnInput[];
-    outputs: ISignTxnOutput[];
+    inputs: ISignTxnInputData[];
+    outputs: ISignTxnOutputData[];
+    rawTxn: string[];
     locktime?: number;
     hashType?: number;
   };

packages/app-btc/src/utils/operationHelper.ts

@@ -3,6 +3,7 @@ import { DeviceAppError, DeviceAppErrorType } from '@cypherock/sdk-interfaces';
 import { OnStatus } from '@cypherock/sdk-utils';
 import { DeepPartial, Exact, Query, Result } from '../proto/generated/btc/core';
 import { assertOrThrowInvalidResult, parseCommonError } from './asserts';
+import { ChunkAck, ChunkPayload } from '../proto/generated/common';
 
 export function decodeResult(data: Uint8Array) {
   let result: Result;
@@ -33,6 +34,8 @@ export class OperationHelper<Q extends QueryKey, R extends ResultKey> {
 
   private readonly onStatus?: OnStatus;
 
+  private static readonly CHUNK_SIZE = 5120;
+
   constructor(params: {
     sdk: ISDK;
     queryKey: Q;
@@ -63,4 +66,57 @@ export class OperationHelper<Q extends QueryKey, R extends ResultKey> {
     parseCommonError((result[this.resultKey] as any).commonError);
     return resultData;
   }
+
+  private static splitIntoChunks(txn: Uint8Array): Uint8Array[] {
+    const chunks: Uint8Array[] = [];
+    const totalChunks = Math.ceil(txn.length / OperationHelper.CHUNK_SIZE);
+
+    for (let i = 0; i < totalChunks; i += 1) {
+      const chunk = txn.slice(
+        i * OperationHelper.CHUNK_SIZE,
+        i * OperationHelper.CHUNK_SIZE + OperationHelper.CHUNK_SIZE,
+      );
+      chunks.push(chunk);
+    }
+
+    return chunks;
+  }
+
+  public async sendInChunks<
+    RK extends keyof Exclude<Result[R], null | undefined>,
+    QK extends keyof Exclude<Query[Q], null | undefined>,
+  >(data: Uint8Array, queryKey: QK, resultKey: RK) {
+    const chunks = OperationHelper.splitIntoChunks(data);
+    let remainingSize = data.length;
+
+    for (let i = 0; i < chunks.length; i += 1) {
+      const chunk = chunks[i];
+      remainingSize -= chunk.length;
+
+      const chunkPayload: ChunkPayload = {
+        chunk,
+        chunkIndex: i,
+        totalChunks: chunks.length,
+        remainingSize,
+      };
+
+      await this.sendQuery({
+        [queryKey]: {
+          chunkPayload,
+        },
+      });
+
+      const result = await this.waitForResult();
+      assertOrThrowInvalidResult(result[resultKey]);
+
+      const { chunkAck } = result[resultKey] as {
+        chunkAck: ChunkAck;
+      };
+
+      assertOrThrowInvalidResult(chunkAck);
+      assertOrThrowInvalidResult(
+        chunkPayload.chunkIndex === chunkAck.chunkIndex,
+      );
+    }
+  }
 }

packages/app-btc/tests/04.signTxn/__fixtures__/error.ts

@@ -32,6 +32,7 @@ const commonParams = {
           sequence: 0xffffffff,
         },
       ],
+      rawTxn: ['0000'],
       outputs: [
         {
           value: '3547271',

packages/app-btc/tests/04.signTxn/__fixtures__/invalidArgs.ts

@@ -31,6 +31,7 @@ const validParams = {
         sequence: 0xffffffff,
       },
     ],
+    rawTxn: ['0000'],
     outputs: [
       {
         value: '3547271',

packages/app-btc/tests/04.signTxn/__fixtures__/invalidData.ts

@@ -31,6 +31,7 @@ const commonParams = {
           sequence: 0xffffffff,
         },
       ],
+      rawTxn: ['0000'],
       outputs: [
         {
           value: '3547271',