@ledgerhq/hw-app-btc 6.20.0 → 6.25.1-alpha.3

package/lib-es/splitTransaction.js.flow

@@ -0,0 +1,145 @@
+// @flow
+import { log } from "@ledgerhq/logs";
+import type { Transaction } from "./types";
+import { getVarint } from "./varint";
+import { formatTransactionDebug } from "./debug";
+
+export function splitTransaction(
+  transactionHex: string,
+  isSegwitSupported: ?boolean = false,
+  hasTimestamp?: boolean = false,
+  hasExtraData?: boolean = false,
+  additionals: Array<string> = []
+): Transaction {
+  const inputs = [];
+  const outputs = [];
+  var witness = false;
+  let offset = 0;
+  let timestamp = Buffer.alloc(0);
+  let nExpiryHeight = Buffer.alloc(0);
+  let nVersionGroupId = Buffer.alloc(0);
+  let extraData = Buffer.alloc(0);
+  const isDecred = additionals.includes("decred");
+  const transaction = Buffer.from(transactionHex, "hex");
+  const version = transaction.slice(offset, offset + 4);
+  const overwinter =
+    version.equals(Buffer.from([0x03, 0x00, 0x00, 0x80])) ||
+    version.equals(Buffer.from([0x04, 0x00, 0x00, 0x80]));
+  offset += 4;
+  if (
+    !hasTimestamp &&
+    isSegwitSupported &&
+    transaction[offset] === 0 &&
+    transaction[offset + 1] !== 0
+  ) {
+    offset += 2;
+    witness = true;
+  }
+  if (hasTimestamp) {
+    timestamp = transaction.slice(offset, 4 + offset);
+    offset += 4;
+  }
+  if (overwinter) {
+    nVersionGroupId = transaction.slice(offset, 4 + offset);
+    offset += 4;
+  }
+  let varint = getVarint(transaction, offset);
+  const numberInputs = varint[0];
+  offset += varint[1];
+  for (let i = 0; i < numberInputs; i++) {
+    const prevout = transaction.slice(offset, offset + 36);
+    offset += 36;
+    let script = Buffer.alloc(0);
+    let tree = Buffer.alloc(0);
+    //No script for decred, it has a witness
+    if (!isDecred) {
+      varint = getVarint(transaction, offset);
+      offset += varint[1];
+      script = transaction.slice(offset, offset + varint[0]);
+      offset += varint[0];
+    } else {
+      //Tree field
+      tree = transaction.slice(offset, offset + 1);
+      offset += 1;
+    }
+
+    const sequence = transaction.slice(offset, offset + 4);
+    offset += 4;
+    inputs.push({ prevout, script, sequence, tree });
+  }
+  varint = getVarint(transaction, offset);
+  const numberOutputs = varint[0];
+  offset += varint[1];
+  for (let i = 0; i < numberOutputs; i++) {
+    const amount = transaction.slice(offset, offset + 8);
+    offset += 8;
+
+    if (isDecred) {
+      //Script version
+      offset += 2;
+    }
+
+    varint = getVarint(transaction, offset);
+    offset += varint[1];
+    const script = transaction.slice(offset, offset + varint[0]);
+    offset += varint[0];
+    outputs.push({ amount, script });
+  }
+  let witnessScript, locktime;
+  if (witness) {
+    witnessScript = transaction.slice(offset, -4);
+    locktime = transaction.slice(transaction.length - 4);
+  } else {
+    locktime = transaction.slice(offset, offset + 4);
+  }
+  offset += 4;
+  if (overwinter || isDecred) {
+    nExpiryHeight = transaction.slice(offset, offset + 4);
+    offset += 4;
+  }
+  if (hasExtraData) {
+    extraData = transaction.slice(offset);
+  }
+
+  //Get witnesses for Decred
+  if (isDecred) {
+    varint = getVarint(transaction, offset);
+    offset += varint[1];
+    if (varint[0] !== numberInputs) {
+      throw new Error("splitTransaction: incoherent number of witnesses");
+    }
+    for (let i = 0; i < numberInputs; i++) {
+      //amount
+      offset += 8;
+      //block height
+      offset += 4;
+      //block index
+      offset += 4;
+      //Script size
+      varint = getVarint(transaction, offset);
+      offset += varint[1];
+      const script = transaction.slice(offset, offset + varint[0]);
+      offset += varint[0];
+      inputs[i].script = script;
+    }
+  }
+
+  const t: Transaction = {
+    version,
+    inputs,
+    outputs,
+    locktime,
+    witness: witnessScript,
+    timestamp,
+    nVersionGroupId,
+    nExpiryHeight,
+    extraData,
+  };
+
+  log(
+    "btc",
+    `splitTransaction ${transactionHex}:\n${formatTransactionDebug(t)}`
+  );
+
+  return t;
+}

package/lib-es/startUntrustedHashTransactionInput.js.flow

@@ -0,0 +1,136 @@
+// @flow
+import type Transport from "@ledgerhq/hw-transport";
+import type { Transaction } from "./types";
+import { createVarint } from "./varint";
+import { MAX_SCRIPT_BLOCK } from "./constants";
+
+export function startUntrustedHashTransactionInputRaw(
+  transport: Transport<*>,
+  newTransaction: boolean,
+  firstRound: boolean,
+  transactionData: Buffer,
+  bip143?: boolean = false,
+  overwinter?: boolean = false,
+  additionals: Array<string> = []
+) {
+  const p2 = additionals.includes("cashaddr")
+    ? 0x03
+    : bip143
+    ? additionals.includes("sapling")
+      ? 0x05
+      : overwinter
+      ? 0x04
+      : 0x02
+    : 0x00;
+  return transport.send(
+    0xe0,
+    0x44,
+    firstRound ? 0x00 : 0x80,
+    newTransaction ? p2 : 0x80,
+    transactionData
+  );
+}
+
+export async function startUntrustedHashTransactionInput(
+  transport: Transport<*>,
+  newTransaction: boolean,
+  transaction: Transaction,
+  inputs: Array<{ trustedInput: boolean, value: Buffer }>,
+  bip143?: boolean = false,
+  overwinter?: boolean = false,
+  additionals: Array<string> = [],
+  useTrustedInputForSegwit?: boolean = false
+) {
+  let data = Buffer.concat([
+    transaction.version,
+    transaction.timestamp || Buffer.alloc(0),
+    transaction.nVersionGroupId || Buffer.alloc(0),
+    createVarint(transaction.inputs.length),
+  ]);
+
+  await startUntrustedHashTransactionInputRaw(
+    transport,
+    newTransaction,
+    true,
+    data,
+    bip143,
+    overwinter,
+    additionals
+  );
+
+  let i = 0;
+  const isDecred = additionals.includes("decred");
+
+  for (let input of transaction.inputs) {
+    let prefix;
+    let inputValue = inputs[i].value;
+    if (bip143) {
+      if (useTrustedInputForSegwit && inputs[i].trustedInput) {
+        prefix = Buffer.from([0x01, inputValue.length]);
+      } else {
+        prefix = Buffer.from([0x02]);
+      }
+    } else {
+      if (inputs[i].trustedInput) {
+        prefix = Buffer.from([0x01, inputs[i].value.length]);
+      } else {
+        prefix = Buffer.from([0x00]);
+      }
+    }
+    data = Buffer.concat([
+      prefix,
+      inputValue,
+      isDecred ? Buffer.from([0x00]) : Buffer.alloc(0),
+      createVarint(input.script.length),
+    ]);
+
+    await startUntrustedHashTransactionInputRaw(
+      transport,
+      newTransaction,
+      false,
+      data,
+      bip143,
+      overwinter,
+      additionals
+    );
+
+    let scriptBlocks = [];
+    let offset = 0;
+
+    if (input.script.length === 0) {
+      scriptBlocks.push(input.sequence);
+    } else {
+      while (offset !== input.script.length) {
+        let blockSize =
+          input.script.length - offset > MAX_SCRIPT_BLOCK
+            ? MAX_SCRIPT_BLOCK
+            : input.script.length - offset;
+        if (offset + blockSize !== input.script.length) {
+          scriptBlocks.push(input.script.slice(offset, offset + blockSize));
+        } else {
+          scriptBlocks.push(
+            Buffer.concat([
+              input.script.slice(offset, offset + blockSize),
+              input.sequence,
+            ])
+          );
+        }
+        offset += blockSize;
+      }
+    }
+
+    for (let scriptBlock of scriptBlocks) {
+      await startUntrustedHashTransactionInputRaw(
+        transport,
+        newTransaction,
+        false,
+        scriptBlock,
+        bip143,
+        overwinter,
+        additionals
+      );
+    }
+
+    i++;
+  }
+}

package/lib-es/types.js.flow

@@ -0,0 +1,31 @@
+// @flow
+
+/**
+ */
+export type TransactionInput = {
+  prevout: Buffer,
+  script: Buffer,
+  sequence: Buffer,
+  tree?: Buffer,
+};
+
+/**
+ */
+export type TransactionOutput = {
+  amount: Buffer,
+  script: Buffer,
+};
+
+/**
+ */
+export type Transaction = {
+  version: Buffer,
+  inputs: TransactionInput[],
+  outputs?: TransactionOutput[],
+  locktime?: Buffer,
+  witness?: Buffer,
+  timestamp?: Buffer,
+  nVersionGroupId?: Buffer,
+  nExpiryHeight?: Buffer,
+  extraData?: Buffer,
+};

package/lib-es/varint.js.flow

@@ -0,0 +1,43 @@
+// @flow
+
+export function getVarint(data: Buffer, offset: number): [number, number] {
+  if (data[offset] < 0xfd) {
+    return [data[offset], 1];
+  }
+  if (data[offset] === 0xfd) {
+    return [(data[offset + 2] << 8) + data[offset + 1], 3];
+  }
+  if (data[offset] === 0xfe) {
+    return [
+      (data[offset + 4] << 24) +
+        (data[offset + 3] << 16) +
+        (data[offset + 2] << 8) +
+        data[offset + 1],
+      5,
+    ];
+  }
+
+  throw new Error("getVarint called with unexpected parameters");
+}
+
+export function createVarint(value: number): Buffer {
+  if (value < 0xfd) {
+    const buffer = Buffer.alloc(1);
+    buffer[0] = value;
+    return buffer;
+  }
+  if (value <= 0xffff) {
+    const buffer = Buffer.alloc(3);
+    buffer[0] = 0xfd;
+    buffer[1] = value & 0xff;
+    buffer[2] = (value >> 8) & 0xff;
+    return buffer;
+  }
+  const buffer = Buffer.alloc(5);
+  buffer[0] = 0xfe;
+  buffer[1] = value & 0xff;
+  buffer[2] = (value >> 8) & 0xff;
+  buffer[3] = (value >> 16) & 0xff;
+  buffer[4] = (value >> 24) & 0xff;
+  return buffer;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/hw-app-btc",
-  "version": "6.20.0",
+  "version": "6.25.1-alpha.3+eb669e17",
   "description": "Ledger Hardware Wallet Bitcoin Application API",
   "keywords": [
     "Ledger",
@@ -27,7 +27,7 @@
   "types": "lib/Btc.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@ledgerhq/hw-transport": "^6.20.0",
+    "@ledgerhq/hw-transport": "^6.25.1-alpha.3+eb669e17",
     "@ledgerhq/logs": "^6.10.0",
     "bip32-path": "^0.4.2",
     "bitcoinjs-lib": "^5.2.0",
@@ -45,5 +45,5 @@
     "watch": "bash ../../script/watch.sh",
     "doc": "bash ../../script/doc.sh"
   },
-  "gitHead": "814218180de877f1c4128af1b9e2dd0fb7dfb0c7"
+  "gitHead": "eb669e17dd87d3ab568beab1f9a5ddb1a2536e83"
 }

package/src/newops/clientCommands.ts

@@ -47,7 +47,7 @@ export class GetPreimageCommand extends ClientCommand {
   }
 
   execute(request: Buffer): Buffer {
-    const req = request.subarray(1);
+    const req = Buffer.from(request.subarray(1));
 
     // we expect no more data to read
     if (req.length != 1 + 32) {
@@ -84,7 +84,7 @@ export class GetPreimageCommand extends ClientCommand {
       return Buffer.concat([
         preimage_len_varint,
         Buffer.from([payload_size]),
-        known_preimage.subarray(0, payload_size),
+        Buffer.from(known_preimage.subarray(0, payload_size)),
       ]);
     }
 
@@ -105,7 +105,7 @@ export class GetMerkleLeafProofCommand extends ClientCommand {
   }
 
   execute(request: Buffer): Buffer {
-    const req = request.subarray(1);
+    const req = Buffer.from(request.subarray(1));
 
     if (req.length < 32 + 1 + 1) {
       throw new Error("Invalid request, expected at least 34 bytes");
@@ -174,7 +174,7 @@ export class GetMerkleLeafIndexCommand extends ClientCommand {
   }
 
   execute(request: Buffer): Buffer {
-    const req = request.subarray(1);
+    const req = Buffer.from(request.subarray(1));
 
     if (req.length != 32 + 32) {
       throw new Error("Invalid request, unexpected trailing data");