@ledgerhq/live-common 21.26.2 → 21.29.0

package/src/exchange/platform/transfer/completeExchange.ts

@@ -0,0 +1,187 @@
+import secp256k1 from "secp256k1";
+import { from, Observable } from "rxjs";
+import { TransportStatusError, WrongDeviceForAccount } from "@ledgerhq/errors";
+
+import { delay } from "../../../promise";
+import ExchangeTransport, {
+  ExchangeTypes,
+} from "../../hw-app-exchange/Exchange";
+import perFamily from "../../../generated/exchange";
+import { getAccountCurrency, getMainAccount } from "../../../account";
+import { getAccountBridge } from "../../../bridge";
+import { TransactionRefusedOnDevice } from "../../../errors";
+import { withDevice } from "../../../hw/deviceAccess";
+import { getCurrencyExchangeConfig } from "../..";
+import { getProvider } from ".";
+
+import type {
+  CompleteExchangeInputFund,
+  CompleteExchangeInputSell,
+  CompleteExchangeRequestEvent,
+} from "../types";
+
+const withDevicePromise = (deviceId, fn) =>
+  withDevice(deviceId)((transport) => from(fn(transport))).toPromise();
+
+const completeExchange = (
+  input: CompleteExchangeInputFund | CompleteExchangeInputSell
+): Observable<CompleteExchangeRequestEvent> => {
+  let { transaction } = input; // TODO build a tx from the data
+
+  const {
+    deviceId,
+    exchange,
+    provider,
+    binaryPayload,
+    signature,
+    exchangeType,
+    rateType, // TODO Pass fixed/float for UI switch ?
+  } = input;
+
+  const { fromAccount, fromParentAccount } = exchange;
+
+  return new Observable((o) => {
+    let unsubscribed = false;
+    let ignoreTransportError = false;
+
+    const confirmExchange = async () => {
+      await withDevicePromise(deviceId, async (transport) => {
+        const providerNameAndSignature = getProvider(exchangeType, provider);
+
+        if (!providerNameAndSignature)
+          throw new Error("Could not get provider infos");
+
+        const exchange = new ExchangeTransport(
+          transport,
+          exchangeType,
+          rateType
+        );
+        const refundAccount = getMainAccount(fromAccount, fromParentAccount);
+        const accountBridge = getAccountBridge(refundAccount);
+        const refundCurrency = getAccountCurrency(refundAccount);
+
+        if (refundCurrency.type !== "CryptoCurrency")
+          throw new Error("This should be a cryptocurrency");
+
+        transaction = await accountBridge.prepareTransaction(
+          refundAccount,
+          transaction
+        );
+        if (unsubscribed) return;
+
+        const { errors, estimatedFees } =
+          await accountBridge.getTransactionStatus(refundAccount, transaction);
+        if (unsubscribed) return;
+
+        const errorsKeys = Object.keys(errors);
+        if (errorsKeys.length > 0) throw errors[errorsKeys[0]]; // throw the first error
+
+        await exchange.setPartnerKey(providerNameAndSignature.nameAndPubkey);
+        if (unsubscribed) return;
+
+        await exchange.checkPartner(providerNameAndSignature.signature);
+        if (unsubscribed) return;
+
+        await exchange.processTransaction(
+          Buffer.from(binaryPayload, "hex"),
+          estimatedFees
+        );
+        if (unsubscribed) return;
+
+        const bufferSignature = Buffer.from(signature, "hex");
+        /**
+         * For the Fund and Swap flow, the signature sent to the nano needs to
+         * be in DER format, which is not the case for Sell flow. Hence the
+         * ternary.
+         * cf. https://github.com/LedgerHQ/app-exchange/blob/e67848f136dc7227521791b91f608f7cd32e7da7/src/check_tx_signature.c#L14-L32
+         */
+        const goodSign =
+          exchangeType === ExchangeTypes.Sell
+            ? bufferSignature
+            : Buffer.from(secp256k1.signatureExport(bufferSignature));
+
+        if (!goodSign) {
+          throw new Error("Could not check provider signature");
+        }
+
+        await exchange.checkTransactionSignature(goodSign);
+        if (unsubscribed) return;
+
+        const payoutAddressParameters = await perFamily[
+          refundCurrency.family
+        ].getSerializedAddressParameters(
+          refundAccount.freshAddressPath,
+          refundAccount.derivationMode,
+          refundCurrency.id
+        );
+        if (unsubscribed) return;
+
+        const {
+          config: payoutAddressConfig,
+          signature: payoutAddressConfigSignature,
+        } = getCurrencyExchangeConfig(refundCurrency);
+
+        try {
+          await exchange.checkPayoutAddress(
+            payoutAddressConfig,
+            payoutAddressConfigSignature,
+            payoutAddressParameters.addressParameters
+          );
+        } catch (e) {
+          // @ts-expect-error TransportStatusError to be typed on ledgerjs
+          if (e instanceof TransportStatusError && e.statusCode === 0x6a83) {
+            throw new WrongDeviceForAccount(undefined, {
+              accountName: refundAccount.name,
+            });
+          }
+
+          throw e;
+        }
+
+        o.next({
+          type: "complete-exchange-requested",
+          estimatedFees,
+        });
+
+        if (unsubscribed) return;
+        ignoreTransportError = true;
+        await exchange.signCoinTransaction();
+      }).catch((e) => {
+        if (ignoreTransportError) return;
+
+        // @ts-expect-error TransportStatusError to be typed on ledgerjs
+        if (e instanceof TransportStatusError && e.statusCode === 0x6a84) {
+          throw new TransactionRefusedOnDevice();
+        }
+
+        throw e;
+      });
+      await delay(3000);
+      if (unsubscribed) return;
+      o.next({
+        type: "complete-exchange-result",
+        completeExchangeResult: transaction,
+      });
+    };
+
+    confirmExchange().then(
+      () => {
+        o.complete();
+        unsubscribed = true;
+      },
+      (e) => {
+        o.next({
+          type: "complete-exchange-error",
+          error: e,
+        });
+        o.complete();
+        unsubscribed = true;
+      }
+    );
+    return () => {
+      unsubscribed = true;
+    };
+  });
+};
+
+export default completeExchange;

package/src/exchange/platform/transfer/index.ts

@@ -0,0 +1,66 @@
+import type { ExchangeProviderNameAndSignature } from "../..";
+import { getEnv } from "../../../env";
+import { ExchangeTypes } from "../../hw-app-exchange/Exchange";
+// FIXME: to be move in this file alongide 'fundProviders' once 'src/exchange/sell/' is deprecated
+import { sellProviders } from "../../sell";
+
+const testFundProvider = {
+  nameAndPubkey: Buffer.from([
+    0x9, 0x46, 0x55, 0x4e, 0x44, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x4, 0x0, 0xbe,
+    0xef, 0x98, 0xb4, 0xb2, 0x99, 0x4f, 0x68, 0x8f, 0xd9, 0x8b, 0x56, 0x5e,
+    0x17, 0x1e, 0xc9, 0x25, 0x9c, 0x89, 0x6, 0x14, 0xd2, 0xdb, 0xa6, 0x10, 0x52,
+    0x2, 0x1, 0x8e, 0x3a, 0x76, 0x4a, 0xa6, 0x68, 0x3e, 0xa1, 0x16, 0xc9, 0xe0,
+    0xe3, 0xc8, 0x1, 0xca, 0x5a, 0xb9, 0x72, 0xa2, 0xf8, 0xf7, 0x9f, 0x90, 0x6e,
+    0x19, 0xf7, 0x3e, 0xdb, 0x91, 0x45, 0x0, 0xea, 0xd0, 0x2d, 0x70,
+  ]),
+  signature: Buffer.from([
+    0x30, 0x44, 0x2, 0x20, 0x3c, 0x1c, 0xe9, 0xea, 0xf2, 0x1a, 0x18, 0x80, 0x3e,
+    0xa9, 0x87, 0x6f, 0xab, 0x8f, 0x8a, 0x24, 0xb0, 0xd6, 0xe5, 0xf2, 0x6e,
+    0xf7, 0x54, 0xf2, 0xd1, 0xa0, 0xac, 0x34, 0x24, 0xfc, 0xb8, 0xe1, 0x2, 0x20,
+    0x4f, 0x6c, 0x92, 0xcf, 0xec, 0x8f, 0x23, 0x2c, 0x1b, 0x14, 0x89, 0x88,
+    0x2f, 0x98, 0x7, 0xf, 0xe3, 0xe2, 0x0, 0x84, 0xd0, 0x23, 0xd6, 0x53, 0xe3,
+    0xee, 0xf6, 0x96, 0xbc, 0xa0, 0x27, 0x78,
+  ]),
+  curve: "secpk256k1",
+};
+
+const fundProviders: Record<
+  string,
+  {
+    nameAndPubkey: Buffer;
+    signature: Buffer;
+    curve: string;
+  }
+> = {
+  // FIXME: no prod provider for now
+};
+
+const getProvider = (
+  exchangeType: ExchangeTypes,
+  providerName: string
+): ExchangeProviderNameAndSignature => {
+  if (getEnv("MOCK_EXCHANGE_TEST_CONFIG")) {
+    return testFundProvider;
+  }
+
+  const res = (() => {
+    switch (exchangeType) {
+      case ExchangeTypes.Fund:
+        return fundProviders[providerName.toLowerCase()];
+
+      case ExchangeTypes.Sell:
+        return sellProviders[providerName.toLowerCase()];
+
+      default:
+        return null;
+    }
+  })();
+
+  if (!res) {
+    throw new Error(`Unknown partner ${providerName}`);
+  }
+
+  return res;
+};
+
+export { getProvider };

package/src/exchange/platform/types.ts

@@ -0,0 +1,76 @@
+import { BigNumber } from "bignumber.js";
+
+import type {
+  Transaction,
+  Account,
+  AccountLike,
+  AccountRaw,
+  AccountRawLike,
+} from "../../types";
+import { ExchangeTypes, RateTypes } from "../hw-app-exchange/Exchange";
+
+export type CompleteExchangeRequestEvent =
+  | { type: "complete-exchange" }
+  | {
+      type: "complete-exchange-requested";
+      estimatedFees: BigNumber;
+    }
+  | {
+      type: "complete-exchange-error";
+      error: Error;
+    }
+  | {
+      type: "complete-exchange-result";
+      completeExchangeResult: Transaction;
+    };
+
+export type ExchangeSwap = {
+  fromParentAccount: Account | null | undefined;
+  fromAccount: AccountLike;
+  toParentAccount: Account | null | undefined;
+  toAccount: AccountLike;
+};
+
+export type ExchangeSwapRaw = {
+  fromParentAccount: AccountRaw | null | undefined;
+  fromAccount: AccountRawLike;
+  toParentAccount: AccountRaw | null | undefined;
+  toAccount: AccountRawLike;
+};
+
+export type ExchangeSell = {
+  fromParentAccount: Account | null | undefined;
+  fromAccount: AccountLike;
+};
+
+export type ExchangeSellRaw = {
+  fromParentAccount: AccountRaw | null | undefined;
+  fromAccount: AccountRawLike;
+};
+
+interface CompleteExchangeInputCommon {
+  rateType: RateTypes;
+  deviceId: string;
+  provider: string;
+  binaryPayload: string;
+  signature: string;
+  transaction: Transaction;
+}
+export interface CompleteExchangeInputSell extends CompleteExchangeInputCommon {
+  readonly exchangeType: ExchangeTypes.Sell;
+  exchange: ExchangeSell;
+}
+
+export interface CompleteExchangeInputFund extends CompleteExchangeInputCommon {
+  readonly exchangeType: ExchangeTypes.Fund;
+  exchange: ExchangeSell;
+}
+
+export interface CompleteExchangeInputSwap extends CompleteExchangeInputCommon {
+  readonly exchangeType: ExchangeTypes.Swap;
+  exchange: ExchangeSwap;
+}
+
+export type Exchange = ExchangeSwap | ExchangeSell;
+
+export type ExchangeRaw = ExchangeSwapRaw | ExchangeSellRaw;

package/src/exchange/sell/checkSignatureAndPrepare.ts

@@ -7,7 +7,7 @@ import { getAccountCurrency, getMainAccount } from "../../account";
 import { getCurrencyExchangeConfig } from "../";
 import perFamily from "../../generated/exchange";
 import type { SellRequestEvent } from "./types";
-import { TRANSACTION_TYPES } from "../hw-app-exchange/Exchange";
+import { ExchangeTypes } from "../hw-app-exchange/Exchange";
 import type {
   Account,
   AccountLike,
@@ -38,7 +38,7 @@ export default async (
     payloadSignature,
     transaction,
   } = input;
-  const exchange = new Exchange(transport, TRANSACTION_TYPES.SELL);
+  const exchange = new Exchange(transport, ExchangeTypes.Sell);
   const mainAccount = getMainAccount(account, parentAccount);
   const { estimatedFees } = status;
   const provider = getProvider("coinify"); // FIXME Don't forget to switch to prod

package/src/exchange/sell/getTransactionId.ts

@@ -1,14 +1,14 @@
 import Transport from "@ledgerhq/hw-transport";
 import Exchange from "../hw-app-exchange/Exchange";
 import type { SellRequestEvent } from "./types";
-import { TRANSACTION_TYPES } from "../hw-app-exchange/Exchange";
+import { ExchangeTypes } from "../hw-app-exchange/Exchange";
 
 function base64EncodeUrl(str) {
   return str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
 
 export default async (transport: Transport): Promise<SellRequestEvent> => {
-  const sell = new Exchange(transport, TRANSACTION_TYPES.SELL);
+  const sell = new Exchange(transport, ExchangeTypes.Sell);
   const txId = await sell.startNewTransaction();
   return {
     type: "init-sell-get-transaction-id",

package/src/exchange/sell/index.ts

@@ -1,6 +1,6 @@
 import type { ExchangeProviderNameAndSignature } from "../";
 
-const sellProviders: Record<
+export const sellProviders: Record<
   string,
   {
     nameAndPubkey: Buffer;

package/src/exchange/swap/completeExchange.ts

@@ -1,36 +1,28 @@
 import { log } from "@ledgerhq/logs";
-import { from } from "rxjs";
+import { from, Observable } from "rxjs";
 import secp256k1 from "secp256k1";
 import { TransportStatusError, WrongDeviceForAccount } from "@ledgerhq/errors";
+
 import { delay } from "../../promise";
 import ExchangeTransport from "../hw-app-exchange/Exchange";
 import perFamily from "../../generated/exchange";
 import { getAccountCurrency, getMainAccount } from "../../account";
 import { getAccountBridge } from "../../bridge";
 import { TransactionRefusedOnDevice } from "../../errors";
-import type { CompleteExchangeRequestEvent, Exchange } from "./types";
-import { Observable } from "rxjs";
 import { withDevice } from "../../hw/deviceAccess";
 import { getProviderNameAndSignature } from "./";
 import { getCurrencyExchangeConfig } from "../";
-import { Transaction } from "../../types";
+
+import type {
+  CompleteExchangeInputSwap,
+  CompleteExchangeRequestEvent,
+} from "../platform/types";
 
 const withDevicePromise = (deviceId, fn) =>
   withDevice(deviceId)((transport) => from(fn(transport))).toPromise();
 
-type CompleteExchangeInput = {
-  exchange: Exchange;
-  deviceId: string;
-  provider: string;
-  binaryPayload: string;
-  signature: string;
-  transaction: Transaction;
-  exchangeType: number;
-  rateType: number;
-};
-
 const completeExchange = (
-  input: CompleteExchangeInput
+  input: CompleteExchangeInputSwap
 ): Observable<CompleteExchangeRequestEvent> => {
   let { transaction } = input; // TODO build a tx from the data
 
@@ -41,7 +33,7 @@ const completeExchange = (
     binaryPayload,
     signature,
     exchangeType,
-    rateType = 0x00, // TODO Pass fixed/float for UI switch ?
+    rateType,
   } = input;
 
   const { fromAccount, fromParentAccount } = exchange;
@@ -131,41 +123,40 @@ const completeExchange = (
 
           throw e;
         }
-        if (exchangeType === 0x00) {
-          // Swap specific checks to confirm the refund address is correct.
-          if (unsubscribed) return;
-          const refundAddressParameters = await perFamily[
-            refundCurrency.family
-          ].getSerializedAddressParameters(
-            refundAccount.freshAddressPath,
-            refundAccount.derivationMode,
-            refundCurrency.id
+
+        // Swap specific checks to confirm the refund address is correct.
+        if (unsubscribed) return;
+        const refundAddressParameters = await perFamily[
+          refundCurrency.family
+        ].getSerializedAddressParameters(
+          refundAccount.freshAddressPath,
+          refundAccount.derivationMode,
+          refundCurrency.id
+        );
+        if (unsubscribed) return;
+
+        const {
+          config: refundAddressConfig,
+          signature: refundAddressConfigSignature,
+        } = getCurrencyExchangeConfig(refundCurrency);
+        if (unsubscribed) return;
+
+        try {
+          await exchange.checkRefundAddress(
+            refundAddressConfig,
+            refundAddressConfigSignature,
+            refundAddressParameters.addressParameters
           );
-          if (unsubscribed) return;
-
-          const {
-            config: refundAddressConfig,
-            signature: refundAddressConfigSignature,
-          } = getCurrencyExchangeConfig(refundCurrency);
-          if (unsubscribed) return;
-
-          try {
-            await exchange.checkRefundAddress(
-              refundAddressConfig,
-              refundAddressConfigSignature,
-              refundAddressParameters.addressParameters
-            );
-            log("exchange", "checkrefund address");
-          } catch (e) {
-            // @ts-expect-error TransportStatusError to be typed on ledgerjs
-            if (e instanceof TransportStatusError && e.statusCode === 0x6a83) {
-              log("exchange", "transport error");
-              throw new WrongDeviceForAccount(undefined, {
-                accountName: refundAccount.name,
-              });
-            }
-            throw e;
+          log("exchange", "checkrefund address");
+        } catch (e) {
+          // @ts-expect-error TransportStatusError to be typed on ledgerjs
+          if (e instanceof TransportStatusError && e.statusCode === 0x6a83) {
+            log("exchange", "transport error");
+            throw new WrongDeviceForAccount(undefined, {
+              accountName: refundAccount.name,
+            });
           }
+          throw e;
         }
 
         o.next({

package/src/exchange/swap/hooks/usePickDefaultAccount.ts

@@ -2,7 +2,7 @@ import { useEffect } from "react";
 import { Account, TokenAccount } from "../../../types";
 import { useCurrenciesByMarketcap } from "../../../currencies/sortByMarketcap";
 import { listCryptoCurrencies, listTokens } from "../../../currencies";
-import { getAccountCurrency } from "../../../account";
+import { getAvailableAccountsById } from "../utils";
 
 // Pick a default source account if none are selected.
 export const usePickDefaultAccount = (
@@ -17,14 +17,9 @@ export const usePickDefaultAccount = (
     if (!fromAccount && allCurrencies.length > 0) {
       const defaultAccount: Account | TokenAccount | undefined = allCurrencies
         .map(({ id }) =>
-          accounts
-            .filter(
-              (acc) =>
-                getAccountCurrency(acc)?.id === id &&
-                acc.balance.gt(0) &&
-                !acc.disabled
-            )
-            .sort((a, b) => b.balance.minus(a.balance).toNumber())
+          getAvailableAccountsById(id, accounts).filter((account) =>
+            account.balance.gt(0)
+          )
         )
         .flat(1)
         .find(Boolean);

package/src/exchange/swap/initSwap.ts

@@ -23,10 +23,7 @@ import { withDevice } from "../../hw/deviceAccess";
 import { getProviderNameAndSignature, getSwapAPIBaseURL } from "./";
 import { getCurrencyExchangeConfig } from "../";
 import { getEnv } from "../../env";
-import {
-  TRANSACTION_RATES,
-  TRANSACTION_TYPES,
-} from "../hw-app-exchange/Exchange";
+import { RateTypes, ExchangeTypes } from "../hw-app-exchange/Exchange";
 
 const withDevicePromise = (deviceId, fn) =>
   withDevice(deviceId)((transport) => from(fn(transport))).toPromise();
@@ -48,9 +45,9 @@ const initSwap = (input: InitSwapInput): Observable<SwapRequestEvent> => {
       await withDevicePromise(deviceId, async (transport) => {
         const ratesFlag =
           exchangeRate.tradeMethod === "fixed"
-            ? TRANSACTION_RATES.FIXED
-            : TRANSACTION_RATES.FLOATING;
-        const swap = new Exchange(transport, TRANSACTION_TYPES.SWAP, ratesFlag);
+            ? RateTypes.Fixed
+            : RateTypes.Floating;
+        const swap = new Exchange(transport, ExchangeTypes.Swap, ratesFlag);
         // NB this id is crucial to prevent replay attacks, if it changes
         // we need to start the flow again.
         const deviceTransactionId = await swap.startNewTransaction();

package/src/exchange/swap/types.ts

@@ -130,20 +130,7 @@ export type SwapRequestEvent =
       type: "init-swap-result";
       initSwapResult: InitSwapResult;
     };
-export type CompleteExchangeRequestEvent =
-  | { type: "complete-exchange" }
-  | {
-      type: "complete-exchange-requested";
-      estimatedFees: BigNumber;
-    }
-  | {
-      type: "complete-exchange-error";
-      error: Error;
-    }
-  | {
-      type: "complete-exchange-result";
-      completeExchangeResult: Transaction;
-    };
+
 export type SwapHistorySection = {
   day: Date;
   data: MappedSwapOperation[];

package/src/exchange/swap/utils/index.test.ts

@@ -1,6 +1,10 @@
 import BigNumber from "bignumber.js";
 
-import { pickExchangeRate, getAccountTuplesForCurrency } from "./index";
+import {
+  pickExchangeRate,
+  getAccountTuplesForCurrency,
+  getAvailableAccountsById,
+} from "./index";
 import { getMockExchangeRate } from "../mock";
 import { genAccount } from "../../../mock/account";
 import type {
@@ -222,3 +226,42 @@ describe("swap/utils/getAccountTuplesForCurrency", () => {
     });
   });
 });
+
+describe("swap/utils/getAvailableAccountsById", () => {
+  const getEthAccount = getAccountCreator("ethereum");
+  const getBtcAccount = getAccountCreator("bitcoin");
+  const getPolkadotAccount = getAccountCreator("polkadot");
+  const getCosmosAccount = getAccountCreator("cosmos");
+
+  test("return the correct accounts after sorting/filtering them", () => {
+    const [
+      disabledAccount,
+      higherBalanceAccount,
+      lowerBalanceAccount,
+      ...accounts
+    ] = new Array(6).fill(null).map(getEthAccount);
+
+    // mutate some accounts to test sorting/filtering
+    disabledAccount.disabled = true;
+    higherBalanceAccount.balance = new BigNumber(10);
+    lowerBalanceAccount.balance = new BigNumber(2);
+
+    const allAccounts: Account[] = [
+      getCosmosAccount(),
+      disabledAccount,
+      higherBalanceAccount,
+      lowerBalanceAccount,
+      ...accounts,
+      getBtcAccount(),
+      getPolkadotAccount(),
+    ];
+
+    const results = getAvailableAccountsById("ethereum", allAccounts);
+    expect(results).toHaveLength(5);
+    expect(results[0].balance.toNumber()).toBeGreaterThan(0);
+    expect(results[1].balance.toNumber()).toBeGreaterThan(0);
+    expect(results[0].balance.toNumber()).toBeGreaterThan(
+      results[1].balance.toNumber()
+    );
+  });
+});

package/src/exchange/swap/utils/index.ts

@@ -1,7 +1,8 @@
 import { CryptoCurrency, TokenCurrency } from "@ledgerhq/cryptoassets";
 import { makeEmptyTokenAccount } from "../../../account";
-import { Account, SubAccount } from "../../../types";
+import { Account, SubAccount, TokenAccount } from "../../../types";
 import type { ExchangeRate } from "../types";
+import { getAccountCurrency } from "../../../account";
 
 export const KYC_STATUS = {
   pending: "pending",
@@ -65,3 +66,13 @@ export function getAccountTuplesForCurrency(
     }))
     .filter((a) => (hideEmpty ? a.account?.balance.gt(0) : true));
 }
+
+export const getAvailableAccountsById = (
+  id: string,
+  accounts: ((Account | TokenAccount) & { disabled?: boolean })[]
+): ((Account | TokenAccount) & {
+  disabled?: boolean | undefined;
+})[] =>
+  accounts
+    .filter((acc) => getAccountCurrency(acc)?.id === id && !acc.disabled)
+    .sort((a, b) => b.balance.minus(a.balance).toNumber());

package/src/exchange/testCurrencyConfig/data/coins.ts

@@ -0,0 +1,20 @@
+/**
+ * FIXME:
+ * Minimal config for now, need to extend it to match prod config
+ * cf. https://github.com/LedgerHQ/ledgerjs/tree/master/packages/cryptoassets/data/exchange
+ */
+
+const coins = [
+  [
+    "bitcoin",
+    "0342544307426974636f696e00",
+    "3045022100cb174382302219dca359c0a4d457b2569e31a06b2c25c0088a2bd3fd6c04386a02202c6d0a5b924a414621067e316f021aa13aa5b2eee2bf36ea3cfddebc053b201b",
+  ],
+  [
+    "ethereum",
+    "0345544808457468657265756d050345544812",
+    "3044022065d7931ab3144362d57e3fdcc5de921fb65024737d917f0ab1f8b173d1ed3c2e022027493568d112dc53c7177f8e5fc915d91a903780a067badf109085a73d360323",
+  ],
+];
+
+export default coins;