@ledgerhq/live-common 21.4.0 → 21.4.1-btcjs.6

package/src/families/bitcoin/logic.ts

@@ -0,0 +1,255 @@
+import cashaddr from "cashaddrjs";
+import bchaddr from "bchaddrjs";
+import { Currency, isValidAddress } from "@ledgerhq/wallet-btc";
+import {
+  RecipientRequired,
+  InvalidAddress,
+  CurrencyNotSupported,
+} from "@ledgerhq/errors";
+import type { Account, CryptoCurrency, CryptoCurrencyIds } from "./../../types";
+import type {
+  BitcoinOutput,
+  BitcoinResources,
+  Transaction,
+  NetworkInfo,
+  UtxoStrategy,
+  CoreBitcoinLikeOutput,
+  CoreBitcoinLikeInput,
+  BitcoinInput,
+} from "./types";
+import { libcoreAmountToBigNumber } from "../../libcore/buildBigNumber";
+
+// correspond ~ to min relay fees but determined empirically for a tx to be accepted by network
+const minFees = {
+  bitcoin: 1000,
+  bitcoin_gold: 1000,
+  pivx: 2000,
+  stakenet: 1000,
+  stealthcoin: 2000,
+  qtum: 4000,
+  stratis: 2000,
+  vertcoin: 2000,
+  viacoin: 2000,
+  peercoin: 2000,
+};
+export const getMinRelayFee = (currency: CryptoCurrency): number =>
+  minFees[currency.id] || 0;
+export const inferFeePerByte = (t: Transaction, networkInfo: NetworkInfo) => {
+  if (t.feesStrategy) {
+    const speed = networkInfo.feeItems.items.find(
+      (item) => t.feesStrategy === item.speed
+    );
+
+    if (!speed) {
+      return networkInfo.feeItems.defaultFeePerByte;
+    }
+
+    return speed.feePerByte;
+  }
+
+  return t.feePerByte || networkInfo.feeItems.defaultFeePerByte;
+};
+export const isValidRecipient = async (params: {
+  currency: CryptoCurrency;
+  recipient: string;
+}): Promise<Error | null | undefined> => {
+  if (!params.recipient) {
+    return Promise.reject(new RecipientRequired(""));
+  }
+
+  let valid: boolean;
+  try {
+    // Optimistically assume params.currency.id is an actual Currency
+    valid = isValidAddress(params.recipient, <Currency>params.currency.id);
+  } catch (e: any) {
+    // isValidAddress() will throw Error if c is not an actual Currency
+    return Promise.reject(new InvalidAddress(e.message));
+  }
+  if (!valid) {
+    return Promise.reject(
+      new InvalidAddress("Invalid address for currency " + params.currency.name)
+    );
+  }
+  return Promise.resolve(null);
+};
+export function isChangeOutput(output: BitcoinOutput): boolean {
+  if (!output.path) return false;
+  const p = output.path.split("/");
+  return p[p.length - 2] === "1";
+}
+
+type UTXOStatus =
+  | {
+      excluded: true;
+      reason: "pickUnconfirmedRBF" | "userExclusion";
+    }
+  | {
+      excluded: false;
+    };
+export const getUTXOStatus = (
+  utxo: BitcoinOutput,
+  utxoStrategy: UtxoStrategy
+): UTXOStatus => {
+  if (!utxoStrategy.pickUnconfirmedRBF && utxo.rbf && !utxo.blockHeight) {
+    return {
+      excluded: true,
+      reason: "pickUnconfirmedRBF",
+    };
+  }
+
+  if (
+    utxoStrategy.excludeUTXOs.some(
+      (u) => u.hash === utxo.hash && u.outputIndex === utxo.outputIndex
+    )
+  ) {
+    return {
+      excluded: true,
+      reason: "userExclusion",
+    };
+  }
+
+  return {
+    excluded: false,
+  };
+};
+
+const bchExplicit = (str: string): string => {
+  const explicit = str.includes(":") ? str : "bitcoincash:" + str;
+
+  try {
+    const { type } = cashaddr.decode(explicit);
+    if (type === "P2PKH") return explicit;
+  } catch (e) {
+    // ignore errors
+  }
+
+  return str;
+};
+
+type CoinLogic = {
+  hasExtraData?: boolean;
+  hasExpiryHeight?: boolean;
+  getAdditionals?: (arg0: { transaction: Transaction }) => string[];
+  asExplicitTransactionRecipient?: (arg0: string) => string;
+  onScreenTransactionRecipient?: (arg0: string) => string;
+  postBuildBitcoinResources?: (
+    arg0: Account,
+    arg1?: BitcoinResources
+  ) => BitcoinResources;
+  syncReplaceAddress?: (addr: string) => string;
+  injectGetAddressParams?: (arg0: Account) => any;
+};
+
+const bchToCashaddrAddressWithoutPrefix = (recipient) =>
+  recipient ? bchaddr.toCashAddress(recipient).split(":")[1] : recipient;
+
+export const perCoinLogic: Record<
+  CryptoCurrencyIds,
+  CoinLogic | null | undefined
+> = {
+  zencash: {
+    hasExtraData: true, // FIXME (legacy) investigate why we need this here and drop
+  },
+  zcash: {
+    hasExtraData: true,
+    hasExpiryHeight: true,
+    getAdditionals: () => ["sapling"], // FIXME (legacy) drop in ledgerjs. we always use sapling now for zcash & kmd
+  },
+  komodo: {
+    hasExtraData: true,
+    hasExpiryHeight: true,
+    getAdditionals: () => ["sapling"], // FIXME (legacy) drop in ledgerjs. we always use sapling now for zcash & kmd
+  },
+  decred: {
+    hasExpiryHeight: true,
+  },
+  bitcoin_gold: {
+    getAdditionals: () => ["bip143"],
+  },
+  bitcoin_cash: {
+    getAdditionals: ({ transaction }) => {
+      const additionals = ["bip143"];
+
+      if (bchExplicit(transaction.recipient).startsWith("bitcoincash:")) {
+        additionals.push("cashaddr");
+      }
+
+      return additionals;
+    },
+    // Due to minimal support, we need to return the explicit format of bitcoincash:.. if it's a P2PKH
+    asExplicitTransactionRecipient: bchExplicit,
+    // to represent what happens on the device, which do not display the bitcoincash: prefix
+    onScreenTransactionRecipient: (str: string): string => {
+      const prefix = "bitcoincash:";
+      return str.startsWith(prefix) ? str.slice(prefix.length) : str;
+    },
+    syncReplaceAddress: (addr) => bchToCashaddrAddressWithoutPrefix(addr),
+    injectGetAddressParams: () => ({
+      forceFormat: "cashaddr",
+    }),
+  },
+};
+
+// TODO vvvvv DEPRECATED, TO BE REMOVED vvvvv
+
+export async function parseBitcoinInput(
+  input: CoreBitcoinLikeInput
+): Promise<BitcoinInput> {
+  const address = await input.getAddress();
+  const rawValue = await input.getValue();
+  const value = rawValue ? await libcoreAmountToBigNumber(rawValue) : null;
+  const previousTxHash = await input.getPreviousTxHash();
+  const previousOutputIndex = await input.getPreviousOutputIndex();
+  return {
+    address,
+    value,
+    previousTxHash,
+    previousOutputIndex,
+  };
+}
+
+export async function parseBitcoinOutput(
+  output: CoreBitcoinLikeOutput
+): Promise<BitcoinOutput> {
+  let blockHeight = await output.getBlockHeight();
+
+  if (!blockHeight || blockHeight < 0) {
+    blockHeight = undefined;
+  }
+
+  const hash = await output.getTransactionHash();
+  const outputIndex = await output.getOutputIndex();
+  const address = await output.getAddress();
+  const derivationPath = await output.getDerivationPath();
+  let path;
+
+  if (derivationPath) {
+    const isDerivationPathNull = await derivationPath.isNull();
+
+    if (!isDerivationPathNull) {
+      path = await derivationPath.toString();
+    }
+  }
+
+  const value = await libcoreAmountToBigNumber(await output.getValue());
+  const rbf = false; // this is unsafe to generically call this at the moment. libcore segfault.
+
+  return {
+    hash,
+    outputIndex,
+    blockHeight,
+    address,
+    isChange: false,
+    path,
+    value,
+    rbf,
+  };
+}
+
+export async function parseBitcoinUTXO(
+  output: CoreBitcoinLikeOutput
+): Promise<BitcoinOutput> {
+  const utxo = await parseBitcoinOutput(output);
+  utxo.rbf = await output.isReplaceable();
+  return utxo;
+}

package/src/families/bitcoin/networks.ts

@@ -0,0 +1,360 @@
+import { BigNumber } from "bignumber.js";
+import type { BitcoinLikeNetworkParameters } from "./types";
+import { BitcoinLikeFeePolicy, BitcoinLikeSigHashType } from "./types";
+
+// TODO Custom parameters from libcore -- not used yet
+/*
+const BIP115_PARAMETERS = {
+  blockHash: "9ec9845acb02fab24e1c0368b3b517c1a4488fba97f0e3459ac053ea01000000",
+  blockHeight: {0xC0,0x1F,0x02};
+};
+//Zcash overwinter
+const ZIP143_PARAMETERS = {
+  3,
+  {0x80},
+  {0x03, 0xC4, 0x82, 0x70},
+  347500
+};
+//Zcash Sapling (starting from block 419200)
+const ZIP_SAPLING_PARAMETERS = {
+  4,
+  {0x80},
+  {0x89, 0x2F, 0x20, 0x85},
+  419200
+};
+*/
+
+export const getNetworkParameters = (
+  networkName: string
+): BitcoinLikeNetworkParameters => {
+  if (networkName === "bitcoin") {
+    return {
+      identifier: "btc",
+      P2PKHVersion: Buffer.from([0x00]),
+      P2SHVersion: Buffer.from([0x05]),
+      xpubVersion: Buffer.from([0x04, 0x88, 0xb2, 0x1e]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(546),
+      messagePrefix: "Bitcoin signed message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "bitcoin_testnet") {
+    return {
+      identifier: "btc_testnet",
+      P2PKHVersion: Buffer.from([0x6f]),
+      P2SHVersion: Buffer.from([0xc4]),
+      xpubVersion: Buffer.from([0x04, 0x35, 0x87, 0xcf]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(546),
+      messagePrefix: "Bitcoin signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "bitcoin_cash") {
+    return {
+      identifier: "abc",
+      P2PKHVersion: Buffer.from([0x00]),
+      P2SHVersion: Buffer.from([0x05]),
+      xpubVersion: Buffer.from([0x04, 0x88, 0xb2, 0x1e]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(5430),
+      messagePrefix: "Bitcoin signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash:
+        BitcoinLikeSigHashType.SIGHASH_ALL |
+        BitcoinLikeSigHashType.SIGHASH_FORKID,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "bitcoin_gold") {
+    return {
+      identifier: "btg",
+      P2PKHVersion: Buffer.from([0x26]),
+      P2SHVersion: Buffer.from([0x17]),
+      xpubVersion: Buffer.from([0x04, 0x88, 0xb2, 0x1e]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(5430),
+      messagePrefix: "Bitcoin gold signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash:
+        BitcoinLikeSigHashType.SIGHASH_ALL |
+        BitcoinLikeSigHashType.SIGHASH_FORKID,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "zcash") {
+    return {
+      identifier: "zec",
+      P2PKHVersion: Buffer.from([0x1c, 0xb8]),
+      P2SHVersion: Buffer.from([0x1c, 0xbd]),
+      xpubVersion: Buffer.from([0x04, 0x88, 0xb2, 0x1e]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "Zcash Signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: ["ZIP"],
+    };
+  } else if (networkName === "zencash") {
+    return {
+      identifier: "zen",
+      P2PKHVersion: Buffer.from([0x20, 0x89]),
+      P2SHVersion: Buffer.from([0x20, 0x96]),
+      xpubVersion: Buffer.from([0x04, 0x88, 0xb2, 0x1e]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "Zencash Signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: ["BIP115"],
+    };
+  } else if (networkName === "litecoin") {
+    return {
+      identifier: "ltc",
+      P2PKHVersion: Buffer.from([0x30]),
+      P2SHVersion: Buffer.from([0x32]),
+      xpubVersion: Buffer.from([0x01, 0x9d, 0xa4, 0x62]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "Litecoin Signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "peercoin") {
+    return {
+      identifier: "ppc",
+      P2PKHVersion: Buffer.from([0x37]),
+      P2SHVersion: Buffer.from([0x75]),
+      xpubVersion: Buffer.from([0xe6, 0xe8, 0xe9, 0xe5]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "PPCoin Signed Message:\n",
+      usesTimestampedTransaction: true,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "digibyte") {
+    return {
+      identifier: "dgb",
+      P2PKHVersion: Buffer.from([0x1e]),
+      P2SHVersion: Buffer.from([0x3f]),
+      xpubVersion: Buffer.from([0x04, 0x88, 0xb2, 0x1e]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "DigiByte Signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "hcash") {
+    return {
+      identifier: "hsr",
+      P2PKHVersion: Buffer.from([0x28]),
+      P2SHVersion: Buffer.from([0x78]),
+      xpubVersion: Buffer.from([0x04, 0x88, 0xc2, 0x1e]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "HShare Signed Message:\n",
+      usesTimestampedTransaction: true,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "qtum") {
+    return {
+      identifier: "qtum",
+      P2PKHVersion: Buffer.from([0x3a]),
+      P2SHVersion: Buffer.from([0x32]),
+      xpubVersion: Buffer.from([0x04, 0x88, 0xb2, 0x1e]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "Qtum Signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "stealthcoin") {
+    return {
+      identifier: "xst",
+      P2PKHVersion: Buffer.from([0x3e]),
+      P2SHVersion: Buffer.from([0x55]),
+      xpubVersion: Buffer.from([0x8f, 0x62, 0x4b, 0x66]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "StealthCoin Signed Message:\n",
+      usesTimestampedTransaction: false,
+      // Used to depend on "version", cf. https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/networks.cpp#L250
+      timestampDelay: new BigNumber(15),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "vertcoin") {
+    return {
+      identifier: "vtc",
+      P2PKHVersion: Buffer.from([0x47]),
+      P2SHVersion: Buffer.from([0x05]),
+      xpubVersion: Buffer.from([0x04, 0x88, 0xb2, 0x1e]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "VertCoin Signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "viacoin") {
+    return {
+      identifier: "via",
+      P2PKHVersion: Buffer.from([0x47]),
+      P2SHVersion: Buffer.from([0x21]),
+      xpubVersion: Buffer.from([0x04, 0x88, 0xb2, 0x1e]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "ViaCoin Signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "dash") {
+    return {
+      identifier: "dash",
+      P2PKHVersion: Buffer.from([0x4c]),
+      P2SHVersion: Buffer.from([0x01]),
+      xpubVersion: Buffer.from([0x02, 0xfe, 0x52, 0xf8]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "DarkCoin Signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "dogecoin") {
+    return {
+      identifier: "doge",
+      P2PKHVersion: Buffer.from([0x1e]),
+      P2SHVersion: Buffer.from([0x16]),
+      xpubVersion: Buffer.from([0x02, 0xfa, 0xca, 0xfd]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "DogeCoin Signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "stratis") {
+    return {
+      identifier: "strat",
+      P2PKHVersion: Buffer.from([0x3f]),
+      P2SHVersion: Buffer.from([0x7d]),
+      xpubVersion: Buffer.from([0x04, 0x88, 0xc2, 0x1e]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "Stratis Signed Message:\n",
+      usesTimestampedTransaction: true,
+      timestampDelay: new BigNumber(15),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "komodo") {
+    return {
+      identifier: "kmd",
+      P2PKHVersion: Buffer.from([0x3c]),
+      P2SHVersion: Buffer.from([0x55]),
+      xpubVersion: Buffer.from([0xf9, 0xee, 0xe4, 0x8d]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "Komodo Signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "poswallet") {
+    return {
+      identifier: "posw",
+      P2PKHVersion: Buffer.from([0x37]),
+      P2SHVersion: Buffer.from([0x55]),
+      xpubVersion: Buffer.from([0x04, 0x88, 0xb2, 0x1e]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "PosWallet Signed Message:\n",
+      usesTimestampedTransaction: true,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "pivx") {
+    return {
+      identifier: "pivx",
+      P2PKHVersion: Buffer.from([0x1e]),
+      P2SHVersion: Buffer.from([0x0d]),
+      xpubVersion: Buffer.from([0x02, 0x2d, 0x25, 0x33]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "DarkNet Signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "clubcoin") {
+    return {
+      identifier: "club",
+      P2PKHVersion: Buffer.from([0x1c]),
+      P2SHVersion: Buffer.from([0x55]),
+      xpubVersion: Buffer.from([0x04, 0x88, 0xb2, 0x1e]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "Clubcoin Signed Message:\n",
+      usesTimestampedTransaction: true,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "decred") {
+    return {
+      identifier: "dcr",
+      P2PKHVersion: Buffer.from([0x07, 0x3f]),
+      P2SHVersion: Buffer.from([0x07, 0x1a]),
+      xpubVersion: Buffer.from([0x02, 0xfd, 0xa9, 0x26]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "Decred Signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  } else if (networkName === "stakenet") {
+    return {
+      identifier: "xsn",
+      P2PKHVersion: Buffer.from([0x4c]),
+      P2SHVersion: Buffer.from([0x10]),
+      xpubVersion: Buffer.from([0x04, 0x88, 0xb2, 0x1e]),
+      feePolicy: BitcoinLikeFeePolicy.PER_BYTE,
+      dustAmount: new BigNumber(10000),
+      messagePrefix: "Stakenet Signed Message:\n",
+      usesTimestampedTransaction: false,
+      timestampDelay: new BigNumber(0),
+      sigHash: BitcoinLikeSigHashType.SIGHASH_ALL,
+      additionalBIPs: [],
+    };
+  }
+
+  throw new Error("No network parameters set for " + networkName);
+};

package/src/families/bitcoin/serialization.ts

@@ -38,6 +38,7 @@ export function toBitcoinOutputRaw({
   outputIndex,
   blockHeight,
   address,
+  isChange,
   path,
   value,
   rbf,
@@ -47,6 +48,7 @@ export function toBitcoinOutputRaw({
     outputIndex,
     blockHeight,
     address,
+    isChange ? 1 : 0,
     path,
     value.toString(),
     rbf ? 1 : 0,
@@ -57,6 +59,7 @@ export function fromBitcoinOutputRaw([
   outputIndex,
   blockHeight,
   address,
+  isChange,
   path,
   value,
   rbf,
@@ -66,6 +69,7 @@ export function fromBitcoinOutputRaw([
     outputIndex,
     blockHeight: blockHeight || undefined,
     address: address || undefined,
+    isChange: !!isChange,
     path: path || undefined,
     value: new BigNumber(value),
     rbf: !!rbf,
@@ -76,6 +80,7 @@ export function toBitcoinResourcesRaw(
 ): BitcoinResourcesRaw {
   return {
     utxos: r.utxos.map(toBitcoinOutputRaw),
+    serializedData: r.serializedData,
   };
 }
 export function fromBitcoinResourcesRaw(
@@ -83,5 +88,6 @@ export function fromBitcoinResourcesRaw(
 ): BitcoinResources {
   return {
     utxos: r.utxos.map(fromBitcoinOutputRaw),
+    serializedData: r.serializedData,
   };
 }

package/src/families/bitcoin/specs.ts

@@ -10,8 +10,7 @@ import { pickSiblings } from "../../bot/specs";
 import { bitcoinPickingStrategy } from "./types";
 import type { MutationSpec, AppSpec } from "../../bot/types";
 import { LowerThanMinimumRelayFee } from "../../errors";
-import { getMinRelayFee } from "./fees";
-import { isChangeOutput, getUTXOStatus } from "./transaction";
+import { getMinRelayFee, getUTXOStatus, isChangeOutput } from "./logic";
 import { DeviceModelId } from "@ledgerhq/devices";
 type Arg = Partial<{
   minimalAmount: BigNumber;
@@ -81,7 +80,11 @@ const genericTest = ({
         ? operation.senders
         : txInputs.map((t) => t.address).filter(Boolean),
       recipients: txOutputs
+        // TODO REPLACE >>>>>>>>>>>>>>>>>>
         .filter((o) => !isChangeOutput(o))
+        /*/ WITH <<<<<<<<<<<<<<<<<<<<<<<<<
+        .filter((o) => !o.isChange)
+        //*/
         .map((t) => t.address)
         .filter(Boolean),
     })

package/src/families/bitcoin/speculos-deviceActions.ts

@@ -2,7 +2,7 @@ import type { DeviceAction } from "../../bot/types";
 import type { Transaction } from "./types";
 import { formatCurrencyUnit } from "../../currencies";
 import { deviceActionFlow } from "../../bot/specs";
-import { perCoinLogic } from "./transaction";
+import { perCoinLogic } from "./logic";
 const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
   steps: [
     {

package/src/families/bitcoin/test-dataset.ts

@@ -19,7 +19,7 @@ import vertcoin from "./datasets/vertcoin";
 import viacoin from "./datasets/viacoin";
 import zcash from "./datasets/zcash";
 const dataset: DatasetTest<Transaction> = {
-  implementations: ["libcore", "mock"],
+  implementations: ["js", "mock"],
   currencies: {
     bitcoin_cash,
     bitcoin_gold,