@ledgerhq/coin-bitcoin 0.4.0-next.0

package/src/networks.ts

@@ -0,0 +1,318 @@
+import { BigNumber } from "bignumber.js";
+import type { BitcoinLikeNetworkParameters } from "./types";
+import { BitcoinLikeFeePolicy, BitcoinLikeSigHashType } from "./types";
+
+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"
+      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: [],
+    };
+  }
+
+  throw new Error("No network parameters set for " + networkName);
+};

package/src/publicAddresses.test.ts

@@ -0,0 +1,9 @@
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
+import { listSupportedCurrencies } from "@ledgerhq/coin-framework/currencies/index";
+test("all bitcoin forks that have a manager app have a defined address in abandonSeedLegacyPerCurrency", () => {
+  const currenciyIds = listSupportedCurrencies()
+    .filter(c => c.family === "bitcoin" && c.managerAppName)
+    .map(c => c.id)
+    .sort();
+  expect(currenciyIds.every(id => getAbandonSeedAddress(id) !== undefined)).toEqual(true);
+});

package/src/serialization.test.ts

@@ -0,0 +1,143 @@
+import BigNumber from "bignumber.js";
+import { assignFromAccountRaw, assignToAccountRaw } from "./serialization";
+import { BitcoinAccount, BitcoinAccountRaw, BitcoinOutput, BitcoinOutputRaw } from "./types";
+
+describe("assignToAccountRaw", () => {
+  let accountMock: BitcoinAccount = {} as BitcoinAccount;
+  let accountRawMock: BitcoinAccountRaw = {} as BitcoinAccountRaw;
+
+  beforeEach(() => {
+    accountMock = {} as BitcoinAccount;
+    accountRawMock = {} as BitcoinAccountRaw;
+  });
+
+  describe("when bitcoinResources is defined", () => {
+    it("should transfer utxos to accountRaw", () => {
+      accountMock.bitcoinResources = {
+        utxos: [],
+      };
+      assignToAccountRaw(accountMock, accountRawMock);
+      expect(accountRawMock.bitcoinResources).not.toEqual(undefined);
+    });
+
+    it("should convert utxos to accountRaw in the right order", () => {
+      const firstUtxoHash = "firstUtxo";
+      const secondUtxoHash = "secondUtxo";
+      accountMock.bitcoinResources = {
+        utxos: [
+          { hash: firstUtxoHash, value: new BigNumber(1) },
+          { hash: secondUtxoHash, value: new BigNumber(2) },
+        ] as BitcoinOutput[],
+      };
+      assignToAccountRaw(accountMock, accountRawMock);
+      expect(accountRawMock.bitcoinResources.utxos[0][0]).toEqual(
+        accountMock.bitcoinResources.utxos[0].hash,
+      );
+      expect(accountRawMock.bitcoinResources.utxos[1][0]).toEqual(
+        accountMock.bitcoinResources.utxos[1].hash,
+      );
+    });
+
+    it("should transfer account raw values correctly", () => {
+      accountMock.bitcoinResources = {
+        utxos: [
+          {
+            hash: "firstUtxo",
+            value: new BigNumber(17),
+            outputIndex: 42,
+            blockHeight: 10,
+            address: "address",
+          },
+        ] as BitcoinOutput[],
+      };
+      assignToAccountRaw(accountMock, accountRawMock);
+      expect(accountRawMock.bitcoinResources.utxos[0][0]).toEqual(
+        accountMock.bitcoinResources.utxos[0].hash,
+      );
+      expect(accountRawMock.bitcoinResources.utxos[0][1]).toEqual(
+        accountMock.bitcoinResources.utxos[0].outputIndex,
+      );
+      expect(accountRawMock.bitcoinResources.utxos[0][2]).toEqual(
+        accountMock.bitcoinResources.utxos[0].blockHeight,
+      );
+      expect(accountRawMock.bitcoinResources.utxos[0][3]).toEqual(
+        accountMock.bitcoinResources.utxos[0].address,
+      );
+      expect(accountRawMock.bitcoinResources.utxos[0][4]).toEqual(
+        accountMock.bitcoinResources.utxos[0].value.toString(),
+      );
+    });
+  });
+
+  describe("when bitcoinResources isn't defined", () => {
+    it("shouldn't edit raw account", () => {
+      assignToAccountRaw(accountMock, accountRawMock);
+      expect(accountRawMock.bitcoinResources).toEqual(undefined);
+    });
+  });
+});
+
+describe("assignFromAccountRaw", () => {
+  let accountMock: BitcoinAccount = {} as BitcoinAccount;
+  let accountRawMock: BitcoinAccountRaw = {} as BitcoinAccountRaw;
+
+  beforeEach(() => {
+    accountMock = {} as BitcoinAccount;
+    accountRawMock = {} as BitcoinAccountRaw;
+  });
+
+  describe("when bitcoinResources is defined", () => {
+    it("should transfer utxos to account", () => {
+      accountRawMock.bitcoinResources = {
+        utxos: [],
+      };
+      assignFromAccountRaw(accountRawMock, accountMock);
+      expect(accountMock.bitcoinResources).not.toEqual(undefined);
+    });
+
+    it("should convert utxos to accountRaw in the right order", () => {
+      accountRawMock.bitcoinResources = {
+        utxos: [
+          ["firstUtxo", 42, 10, "address", "17", 0, 0],
+          ["secondUtxo", 42, 10, "address", "17", 0, 0],
+        ] as BitcoinOutputRaw[],
+      };
+      assignFromAccountRaw(accountRawMock, accountMock);
+      expect(accountMock.bitcoinResources.utxos[0].hash).toEqual(
+        accountRawMock.bitcoinResources.utxos[0][0],
+      );
+      expect(accountMock.bitcoinResources.utxos[1].hash).toEqual(
+        accountRawMock.bitcoinResources.utxos[1][0],
+      );
+    });
+
+    it("should convert utxos to account", () => {
+      accountRawMock.bitcoinResources = {
+        utxos: [["firstUtxo", 42, 10, "address", "17", 0, 0]] as BitcoinOutputRaw[],
+      };
+      assignFromAccountRaw(accountRawMock, accountMock);
+      expect(accountMock.bitcoinResources.utxos[0].hash).toEqual(
+        accountRawMock.bitcoinResources.utxos[0][0],
+      );
+      expect(accountMock.bitcoinResources.utxos[0].outputIndex).toEqual(
+        accountRawMock.bitcoinResources.utxos[0][1],
+      );
+      expect(accountMock.bitcoinResources.utxos[0].blockHeight).toEqual(
+        accountRawMock.bitcoinResources.utxos[0][2],
+      );
+      expect(accountMock.bitcoinResources.utxos[0].address).toEqual(
+        accountRawMock.bitcoinResources.utxos[0][3],
+      );
+      expect(accountMock.bitcoinResources.utxos[0].value).toEqual(
+        new BigNumber(accountRawMock.bitcoinResources.utxos[0][4]),
+      );
+    });
+  });
+
+  describe("when bitcoinResources isn't defined", () => {
+    it("shouldn't edit raw account", () => {
+      assignFromAccountRaw(accountRawMock, accountMock);
+      expect(accountMock.bitcoinResources).toEqual(undefined);
+    });
+  });
+});

package/src/serialization.ts

@@ -0,0 +1,94 @@
+import { BigNumber } from "bignumber.js";
+import type {
+  BitcoinResourcesRaw,
+  BitcoinResources,
+  BitcoinInputRaw,
+  BitcoinInput,
+  BitcoinOutputRaw,
+  BitcoinOutput,
+  BitcoinAccountRaw,
+  BitcoinAccount,
+} from "./types";
+import wallet from "./wallet-btc";
+import { Account, AccountRaw } from "@ledgerhq/types-live";
+
+export function toBitcoinInputRaw({
+  address,
+  value,
+  previousTxHash,
+  previousOutputIndex,
+}: BitcoinInput): BitcoinInputRaw {
+  return [address, value ? value.toString() : undefined, previousTxHash, previousOutputIndex];
+}
+export function fromBitcoinInputRaw([
+  address,
+  value,
+  previousTxHash,
+  previousOutputIndex,
+]: BitcoinInputRaw): BitcoinInput {
+  return {
+    address: address || undefined,
+    value: value ? new BigNumber(value) : undefined,
+    previousTxHash: previousTxHash || undefined,
+    previousOutputIndex,
+  };
+}
+export function toBitcoinOutputRaw({
+  hash,
+  outputIndex,
+  blockHeight,
+  address,
+  value,
+  rbf,
+  isChange,
+}: BitcoinOutput): BitcoinOutputRaw {
+  return [hash, outputIndex, blockHeight, address, value.toString(), rbf ? 1 : 0, isChange ? 1 : 0];
+}
+export function fromBitcoinOutputRaw([
+  hash,
+  outputIndex,
+  blockHeight,
+  address,
+  value,
+  rbf,
+  isChange,
+]: BitcoinOutputRaw): BitcoinOutput {
+  return {
+    hash,
+    outputIndex,
+    blockHeight: blockHeight || undefined,
+    address: address || undefined,
+    value: new BigNumber(value),
+    rbf: !!rbf,
+    isChange: !!isChange,
+  };
+}
+
+export function toBitcoinResourcesRaw(r: BitcoinResources): BitcoinResourcesRaw {
+  return {
+    utxos: r.utxos.map(toBitcoinOutputRaw),
+    walletAccount: r.walletAccount && wallet.exportToSerializedAccountSync(r.walletAccount),
+  };
+}
+
+export function fromBitcoinResourcesRaw(r: BitcoinResourcesRaw): BitcoinResources {
+  return {
+    utxos: r.utxos.map(fromBitcoinOutputRaw),
+    walletAccount: r.walletAccount && wallet.importFromSerializedAccountSync(r.walletAccount),
+  };
+}
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw) {
+  const bitcoinAccount = account as BitcoinAccount;
+  if (bitcoinAccount.bitcoinResources) {
+    (accountRaw as BitcoinAccountRaw).bitcoinResources = toBitcoinResourcesRaw(
+      bitcoinAccount.bitcoinResources,
+    );
+  }
+}
+
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
+  const bitcoinResourcesRaw = (accountRaw as BitcoinAccountRaw).bitcoinResources;
+  if (bitcoinResourcesRaw)
+    (account as BitcoinAccount).bitcoinResources = fromBitcoinResourcesRaw(bitcoinResourcesRaw);
+}

package/src/signer.ts

@@ -0,0 +1,82 @@
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+export type BitcoinXPub = string;
+export type BitcoinAddress = {
+  publicKey: string;
+  bitcoinAddress: string;
+  chainCode: string;
+};
+export type BitcoinSignature = {
+  v: number;
+  r: string;
+  s: string;
+};
+export type AddressFormat = "legacy" | "p2sh" | "bech32" | "bech32m" | "cashaddr";
+
+export interface BitcoinSigner {
+  getWalletXpub(arg: { path: string; xpubVersion: number }): Promise<BitcoinXPub>;
+  getWalletPublicKey(
+    path: string,
+    opts?: {
+      verify?: boolean;
+      format?: AddressFormat;
+    },
+  ): Promise<BitcoinAddress>;
+  signMessage(path: string, messageHex: string): Promise<BitcoinSignature>;
+
+  splitTransaction(
+    transactionHex: string,
+    isSegwitSupported: boolean | null | undefined,
+    hasTimestamp: boolean | null | undefined,
+    hasExtraData: boolean | null | undefined,
+    additionals: Array<string> | null | undefined,
+  ): SignerTransaction;
+  createPaymentTransaction(arg: CreateTransaction): Promise<string>;
+}
+
+export type SignerResult = BitcoinXPub | BitcoinAddress | BitcoinSignature;
+export type SignerContext = <T>(
+  deviceId: string,
+  crypto: CryptoCurrency,
+  fn: (signer: BitcoinSigner) => Promise<T>,
+) => Promise<T>;
+
+// The following types are directly extracted from hw-app-btc
+// The goal would be to either share them in a third party lib, or find a pivot format, or marshallize them...
+export type SignerTransactionInput = {
+  prevout: Buffer;
+  script: Buffer;
+  sequence: Buffer;
+  tree?: Buffer;
+};
+export type SignerTransactionOutput = {
+  amount: Buffer;
+  script: Buffer;
+};
+export type SignerTransaction = {
+  version: Buffer;
+  inputs: SignerTransactionInput[];
+  outputs?: SignerTransactionOutput[];
+  locktime?: Buffer;
+  witness?: Buffer;
+  timestamp?: Buffer;
+  nVersionGroupId?: Buffer;
+  nExpiryHeight?: Buffer;
+  extraData?: Buffer;
+};
+export type CreateTransaction = {
+  inputs: Array<[SignerTransaction, number, string | null | undefined, number | null | undefined]>;
+  associatedKeysets: string[];
+  changePath?: string;
+  outputScriptHex: string;
+  lockTime?: number;
+  sigHashType?: number;
+  segwit?: boolean;
+  initialTimestamp?: number;
+  additionals: Array<string>;
+  expiryHeight?: Buffer;
+  useTrustedInputForSegwit?: boolean;
+  onDeviceStreaming?: (arg0: { progress: number; total: number; index: number }) => void;
+  onDeviceSignatureRequested?: () => void;
+  onDeviceSignatureGranted?: () => void;
+};