@ledgerhq/live-common 23.0.0-next.0 → 23.0.0-next.3

package/src/families/cardano/api/api-types.ts

@@ -0,0 +1,33 @@
+import { ProtocolParams } from "../types";
+
+type APIToken = { assetName: string; policyId: string; value: string };
+
+type APIMetadata = { label: string; value: string };
+
+export type APITransaction = {
+  fees: string;
+  hash: string;
+  timestamp: string;
+  blockHeight: number;
+  inputs: Array<{
+    txId: string;
+    index: number;
+    address: string;
+    value: string;
+    paymentKey: string;
+    tokens: Array<APIToken>;
+  }>;
+  outputs: Array<{
+    address: string;
+    value: string;
+    paymentKey: string;
+    tokens: Array<APIToken>;
+  }>;
+  metadata?: {
+    data: Array<APIMetadata>;
+  };
+};
+
+export type APINetworkInfo = {
+  protocolParams: ProtocolParams;
+};

package/src/families/cardano/api/getNetworkInfo.ts

@@ -0,0 +1,38 @@
+import network from "../../../network";
+import { Account, CryptoCurrency } from "../../../types";
+import { APINetworkInfo } from "./api-types";
+import { getEpoch, isTestnet } from "../logic";
+import {
+  CARDANO_API_ENDPOINT,
+  CARDANO_TESTNET_API_ENDPOINT,
+} from "../constants";
+
+async function fetchNetworkInfo(
+  currency: CryptoCurrency
+): Promise<APINetworkInfo> {
+  const res = await network({
+    method: "GET",
+    url: isTestnet(currency)
+      ? `${CARDANO_TESTNET_API_ENDPOINT}/v1/network/info`
+      : `${CARDANO_API_ENDPOINT}/v1/network/info`,
+  });
+  return res && (res.data as APINetworkInfo);
+}
+
+export async function getNetworkInfo(
+  a: Account | undefined,
+  currency: CryptoCurrency
+): Promise<APINetworkInfo> {
+  if (a && a.cardanoResources) {
+    const currencyId = a.currency.id;
+    const currentEpoch = getEpoch(currencyId, new Date());
+    const lastSyncedEpoch = getEpoch(currencyId, a.lastSyncDate);
+
+    if (currentEpoch === lastSyncedEpoch) {
+      return {
+        protocolParams: a.cardanoResources.protocolParams,
+      };
+    }
+  }
+  return fetchNetworkInfo(currency);
+}

package/src/families/cardano/api/getTransactions.ts

@@ -0,0 +1,240 @@
+import network from "../../../network";
+import * as ApiTypes from "./api-types";
+import { Bip32PublicKey } from "@stricahq/bip32ed25519";
+import { PaymentChain, PaymentCredential } from "../types";
+import { getEnv } from "../../../env";
+import {
+  getBipPath,
+  getCredentialKey,
+  getExtendedPublicKeyFromHex,
+  isTestnet,
+} from "../logic";
+import range from "lodash/range";
+import chunk from "lodash/chunk";
+import { Account, CryptoCurrency } from "../../../types";
+import { APITransaction } from "./api-types";
+import {
+  CARDANO_API_ENDPOINT,
+  CARDANO_TESTNET_API_ENDPOINT,
+} from "../constants";
+
+async function fetchTransactions(
+  paymentKeys: Array<string>,
+  pageNo: number,
+  blockHeight: number,
+  currency: CryptoCurrency
+): Promise<{
+  pageNo: number;
+  limit: number;
+  blockHeight: number;
+  transactions: Array<APITransaction>;
+}> {
+  const res = await network({
+    method: "POST",
+    url: isTestnet(currency)
+      ? `${CARDANO_TESTNET_API_ENDPOINT}/v1/transaction`
+      : `${CARDANO_API_ENDPOINT}/v1/transaction`,
+    data: {
+      paymentKeys,
+      pageNo,
+      blockHeight,
+    },
+  });
+  return res.data;
+}
+
+async function getAllTransactionsByKeys(
+  paymentKeys: Array<string>,
+  blockHeight: number,
+  currency: CryptoCurrency
+): Promise<{
+  transactions: Array<ApiTypes.APITransaction>;
+  blockHeight: number;
+}> {
+  const transactions: Array<ApiTypes.APITransaction> = [];
+  let latestBlockHeight = 0;
+  let isAllTrxFetched = false;
+  let pageNo = 1;
+
+  while (!isAllTrxFetched) {
+    const res = await fetchTransactions(
+      paymentKeys,
+      pageNo,
+      blockHeight,
+      currency
+    );
+    transactions.push(...res.transactions);
+    latestBlockHeight = Math.max(res.blockHeight, latestBlockHeight);
+    isAllTrxFetched = res.transactions.length < res.limit;
+    pageNo += 1;
+  }
+  return {
+    transactions,
+    blockHeight: latestBlockHeight,
+  };
+}
+
+async function getSyncedTransactionsByChain(
+  accountPubKey: Bip32PublicKey,
+  accountIndex: number,
+  chainType: PaymentChain,
+  blockHeight: number,
+  initialPaymentCredentials: Array<PaymentCredential>,
+  currency: CryptoCurrency
+): Promise<{
+  transactions: Array<ApiTypes.APITransaction>;
+  latestBlockHeight: number;
+  paymentCredentials: Array<PaymentCredential>;
+}> {
+  const keyChainRange = getEnv("KEYCHAIN_OBSERVABLE_RANGE") || 20;
+
+  // credentialsMap for efficient use
+  const initialPaymentCredentialMap: Record<string, PaymentCredential> = {};
+  let maxUsedKeyIndex = -1;
+  initialPaymentCredentials.forEach((cred) => {
+    initialPaymentCredentialMap[cred.key] = cred;
+    if (cred.isUsed) maxUsedKeyIndex = cred.path.index;
+  });
+
+  const transactions: Array<ApiTypes.APITransaction> = [];
+  let latestBlockHeight = 0;
+
+  // fetch transactions for existing keys
+  const trxsRes = await Promise.all(
+    chunk(Object.keys(initialPaymentCredentialMap), keyChainRange).map((keys) =>
+      getAllTransactionsByKeys(keys, blockHeight, currency)
+    )
+  );
+  trxsRes.forEach((txRes) => {
+    transactions.push(...txRes.transactions);
+    latestBlockHeight = Math.max(latestBlockHeight, txRes.blockHeight);
+  });
+
+  // fetch transactions for new avaialble keys
+  let newPaymentCredentialsMap: Record<string, PaymentCredential> = {};
+  let lastSyncedKeyIndex = initialPaymentCredentials.length
+    ? initialPaymentCredentials[initialPaymentCredentials.length - 1].path.index
+    : -1;
+  let syncToKeyIndex = maxUsedKeyIndex + keyChainRange;
+  while (syncToKeyIndex !== lastSyncedKeyIndex) {
+    const currentPaymentKeysMap: Record<string, PaymentCredential> = {};
+    range(lastSyncedKeyIndex + 1, syncToKeyIndex + 1, 1).forEach((keyIndex) => {
+      const keyPath = getCredentialKey(
+        accountPubKey,
+        getBipPath({
+          account: accountIndex,
+          chain: chainType,
+          index: keyIndex,
+        })
+      );
+      currentPaymentKeysMap[keyPath.key] = {
+        isUsed: false,
+        key: keyPath.key,
+        path: keyPath.path,
+      };
+    });
+    const trxRes = await getAllTransactionsByKeys(
+      Object.keys(currentPaymentKeysMap),
+      blockHeight,
+      currency
+    );
+    transactions.push(...trxRes.transactions);
+
+    lastSyncedKeyIndex = syncToKeyIndex;
+    latestBlockHeight = Math.max(latestBlockHeight, trxRes.blockHeight);
+    newPaymentCredentialsMap = Object.assign(
+      {},
+      newPaymentCredentialsMap,
+      currentPaymentKeysMap
+    );
+    maxUsedKeyIndex = trxRes.transactions.reduce(
+      (maxIndexA, { inputs, outputs }) =>
+        [...inputs, ...outputs].reduce(
+          (maxIndexB, io) =>
+            Math.max(
+              newPaymentCredentialsMap[io.paymentKey]?.path.index || -1,
+              maxIndexB
+            ),
+          maxIndexA
+        ),
+      maxUsedKeyIndex
+    );
+    syncToKeyIndex = maxUsedKeyIndex + keyChainRange;
+  }
+
+  const availablePaymentCredentialsMap = {
+    ...initialPaymentCredentialMap,
+    ...newPaymentCredentialsMap,
+  };
+  transactions.forEach((trx) => {
+    [...trx.inputs, ...trx.outputs].forEach((io) => {
+      if (availablePaymentCredentialsMap[io.paymentKey]) {
+        availablePaymentCredentialsMap[io.paymentKey].isUsed = true;
+      }
+    });
+  });
+
+  return {
+    transactions,
+    latestBlockHeight,
+    paymentCredentials: Object.values(availablePaymentCredentialsMap).sort(
+      (aCred, bCred) => aCred.path.index - bCred.path.index
+    ),
+  };
+}
+
+export async function getTransactions(
+  xpub: string,
+  accountIndex: number,
+  initialAccount: Account | undefined,
+  blockHeight: number,
+  currency: CryptoCurrency
+): Promise<{
+  transactions: Array<ApiTypes.APITransaction>;
+  blockHeight: number;
+  externalCredentials: Array<PaymentCredential>;
+  internalCredentials: Array<PaymentCredential>;
+}> {
+  const accountPubKey = getExtendedPublicKeyFromHex(xpub);
+  const oldExternalCredentials =
+    initialAccount?.cardanoResources?.externalCredentials || [];
+  const oldInternalCredentials =
+    initialAccount?.cardanoResources?.internalCredentials || [];
+
+  const [
+    {
+      transactions: externalKeyTransactions,
+      latestBlockHeight: aBlockHeight,
+      paymentCredentials: externalCredentials,
+    },
+    {
+      transactions: internalKeyTransactions,
+      latestBlockHeight: bBlockHeight,
+      paymentCredentials: internalCredentials,
+    },
+  ] = await Promise.all([
+    getSyncedTransactionsByChain(
+      accountPubKey,
+      accountIndex,
+      PaymentChain.external,
+      blockHeight,
+      oldExternalCredentials,
+      currency
+    ),
+    getSyncedTransactionsByChain(
+      accountPubKey,
+      accountIndex,
+      PaymentChain.internal,
+      blockHeight,
+      oldInternalCredentials,
+      currency
+    ),
+  ]);
+
+  return {
+    transactions: [...externalKeyTransactions, ...internalKeyTransactions],
+    blockHeight: Math.max(aBlockHeight, bBlockHeight),
+    externalCredentials,
+    internalCredentials,
+  };
+}

package/src/families/cardano/api/submitTransaction.ts

@@ -0,0 +1,27 @@
+import { CryptoCurrency } from "@ledgerhq/cryptoassets";
+import network from "../../../network";
+import {
+  CARDANO_API_ENDPOINT,
+  CARDANO_TESTNET_API_ENDPOINT,
+} from "../constants";
+import { isTestnet } from "../logic";
+import { APITransaction } from "./api-types";
+
+export async function submitTransaction({
+  transaction,
+  currency,
+}: {
+  transaction: string;
+  currency: CryptoCurrency;
+}): Promise<APITransaction> {
+  const res = await network({
+    method: "POST",
+    url: isTestnet(currency)
+      ? `${CARDANO_TESTNET_API_ENDPOINT}/v1/transaction/submit`
+      : `${CARDANO_API_ENDPOINT}/v1/transaction/submit`,
+    data: {
+      transaction: transaction,
+    },
+  });
+  return res.data.transaction;
+}

package/src/families/cardano/bridge/js.ts

@@ -0,0 +1,35 @@
+import type { Transaction } from "../types";
+import type { AccountBridge, CurrencyBridge } from "../../../types";
+import { scanAccounts, sync } from "../js-synchronisation";
+import estimateMaxSpendable from "../js-estimateMaxSpendable";
+import {
+  createTransaction,
+  prepareTransaction,
+  updateTransaction,
+} from "../js-transaction";
+import getTransactionStatus from "../js-getTransactionStatus";
+import signOperation from "../js-signOperation";
+import broadcast from "../js-broadcast";
+import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
+
+const receive = makeAccountBridgeReceive();
+
+const accountBridge: AccountBridge<Transaction> = {
+  estimateMaxSpendable,
+  createTransaction,
+  updateTransaction,
+  getTransactionStatus,
+  prepareTransaction,
+  sync,
+  receive,
+  signOperation,
+  broadcast,
+};
+
+const currencyBridge: CurrencyBridge = {
+  scanAccounts,
+  preload: async () => ({}),
+  hydrate: () => {},
+};
+
+export default { currencyBridge, accountBridge };

package/src/families/cardano/bridge.test.ts

@@ -0,0 +1,6 @@
+import { setup } from "../../__tests__/test-helpers/libcore-setup";
+import { testBridge } from "../../__tests__/test-helpers/bridge";
+import dataset from "./test-dataset";
+
+setup("cardano_testnet");
+testBridge("cardano_testnet", dataset);

package/src/families/cardano/buildSubAccounts.ts

@@ -0,0 +1,182 @@
+import BigNumber from "bignumber.js";
+import { encodeOperationId } from "../../operation";
+import { Account, CryptoCurrency, Operation, TokenAccount } from "../../types";
+import { APITransaction } from "./api/api-types";
+import { getAccountChange, getMemoFromTx, isHexString } from "./logic";
+import { PaymentCredential, Token } from "./types";
+import { utils as TyphonUtils } from "@stricahq/typhonjs";
+import { findTokenById } from "@ledgerhq/cryptoassets";
+import {
+  decodeTokenAccountId,
+  emptyHistoryCache,
+  encodeTokenAccountId,
+} from "../../account";
+import { groupBy, keyBy } from "lodash";
+import { mergeOps } from "../../bridge/jsHelpers";
+
+export const getTokenAssetId = ({
+  policyId,
+  assetName,
+}: {
+  policyId: string;
+  assetName: string;
+}): string => `${policyId}${assetName}`;
+
+export const decodeTokenAssetId = (
+  id: string
+): { policyId: string; assetName: string } => {
+  const policyId = id.slice(0, 56);
+  const assetName = id.slice(56);
+  return { policyId, assetName };
+};
+
+const encodeTokenCurrencyId = (
+  parentCurrency: CryptoCurrency,
+  assetId: string
+): string => `${parentCurrency.id}/native/${assetId}`;
+
+export const decodeTokenCurrencyId = (
+  id: string
+): { parentCurrencyId: string; type: string; assetId: string } => {
+  const [parentCurrencyId, type, assetId] = id.split("/");
+  return {
+    parentCurrencyId,
+    type,
+    assetId,
+  };
+};
+
+/**
+ * @returns operations of tokens that are defined in ledgerjs cryptoassets
+ */
+const mapTxToTokenAccountOperation = ({
+  parentAccountId,
+  parentCurrency,
+  newTransactions,
+  accountCredentialsMap,
+}: {
+  parentAccountId: string;
+  parentCurrency: CryptoCurrency;
+  newTransactions: Array<APITransaction>;
+  accountCredentialsMap: Record<string, PaymentCredential>;
+}): Array<Operation> => {
+  const operations: Array<Operation> = [];
+
+  newTransactions.forEach((tx) => {
+    const accountChange = getAccountChange(tx, accountCredentialsMap);
+    accountChange.tokens.forEach((token) => {
+      const assetId = getTokenAssetId({
+        policyId: token.policyId,
+        assetName: token.assetName,
+      });
+      const tokenCurrencyId = encodeTokenCurrencyId(parentCurrency, assetId);
+      const tokenCurrency = findTokenById(tokenCurrencyId);
+      // skip the unsupported tokens by ledger-live
+      if (tokenCurrency === null || tokenCurrency === undefined) {
+        return;
+      }
+
+      const tokenAccountId = encodeTokenAccountId(
+        parentAccountId,
+        tokenCurrency
+      );
+
+      const tokenOperationType = token.amount.lt(0) ? "OUT" : "IN";
+      const memo = getMemoFromTx(tx);
+      const operation: Operation = {
+        accountId: tokenAccountId,
+        id: encodeOperationId(tokenAccountId, tx.hash, tokenOperationType),
+        hash: tx.hash,
+        type: tokenOperationType,
+        fee: new BigNumber(tx.fees),
+        value: token.amount.absoluteValue(),
+        senders: tx.inputs.map((i) =>
+          isHexString(i.address)
+            ? TyphonUtils.getAddressFromHex(i.address).getBech32()
+            : i.address
+        ),
+        recipients: tx.outputs.map((o) =>
+          isHexString(o.address)
+            ? TyphonUtils.getAddressFromHex(o.address).getBech32()
+            : o.address
+        ),
+        blockHeight: tx.blockHeight,
+        date: new Date(tx.timestamp),
+        extra: {
+          memo,
+        },
+        blockHash: undefined,
+      };
+      operations.push(operation);
+    });
+  });
+
+  return operations;
+};
+
+export function buildSubAccounts({
+  initialAccount,
+  parentAccountId,
+  parentCurrency,
+  newTransactions,
+  tokens,
+  accountCredentialsMap,
+}: {
+  initialAccount: Account | undefined;
+  parentAccountId: string;
+  parentCurrency: CryptoCurrency;
+  newTransactions: Array<APITransaction>;
+  tokens: Array<Token>;
+  accountCredentialsMap: Record<string, PaymentCredential>;
+}): Array<TokenAccount> {
+  const tokenAccountsById: Record<string, TokenAccount> = {};
+
+  if (initialAccount && initialAccount.subAccounts) {
+    for (const existingAccount of initialAccount.subAccounts) {
+      if (existingAccount.type === "TokenAccount") {
+        tokenAccountsById[existingAccount.id] = existingAccount;
+      }
+    }
+  }
+
+  const tokenOperations: Array<Operation> = mapTxToTokenAccountOperation({
+    parentAccountId,
+    parentCurrency,
+    newTransactions: newTransactions,
+    accountCredentialsMap,
+  });
+  const tokenOperationsByAccId = groupBy(tokenOperations, (o) => o.accountId);
+  const tokensBalanceByAssetId = keyBy(tokens, (t) => getTokenAssetId(t));
+  for (const tokenAccountId in tokenOperationsByAccId) {
+    const initialTokenAccount = tokenAccountsById[tokenAccountId];
+    const oldOperations = initialTokenAccount?.operations || [];
+    const newOperations = tokenOperationsByAccId[tokenAccountId] || [];
+    const operations = mergeOps(oldOperations, newOperations);
+    const { token: tokenCurrency } = decodeTokenAccountId(tokenAccountId);
+    if (tokenCurrency) {
+      const accountBalance =
+        tokensBalanceByAssetId[tokenCurrency.contractAddress]?.amount ||
+        new BigNumber(0);
+      const tokenAccount: TokenAccount = {
+        type: "TokenAccount",
+        id: tokenAccountId,
+        parentId: parentAccountId,
+        token: tokenCurrency,
+        balance: accountBalance,
+        spendableBalance: accountBalance,
+        creationDate:
+          operations.length > 0
+            ? operations[operations.length - 1].date
+            : new Date(),
+        operationsCount: operations.length,
+        operations,
+        pendingOperations: [],
+        starred: false,
+        balanceHistoryCache: emptyHistoryCache,
+        swapHistory: [],
+      };
+      tokenAccountsById[tokenAccountId] = tokenAccount;
+    }
+  }
+  return Object.values(tokenAccountsById);
+}

package/src/families/cardano/cli-transaction.ts

@@ -0,0 +1,78 @@
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+import { getAccountCurrency } from "../../account";
+import type { AccountLike, Account } from "../../types";
+import { TokenAccount } from "../solana/api/chain/account/token";
+import { Transaction } from "./types";
+
+const options = [
+  {
+    name: "mode",
+    type: String,
+    desc: "mode of transaction: send",
+  },
+  {
+    name: "token",
+    type: String,
+    desc: "uses subAccount(TokenAccount) of the account",
+  },
+];
+
+function inferAccounts(
+  account: Account,
+  opts: Record<string, any>
+): Account[] | TokenAccount[] {
+  invariant(account.currency.family === "cardano", "cardano family");
+
+  if (!opts.token) {
+    const accounts: Account[] = [account];
+    return accounts;
+  }
+
+  return opts.token.map((token) => {
+    const subAccounts = account.subAccounts || [];
+
+    const subAccount = subAccounts.find((a) => {
+      const currency = getAccountCurrency(a);
+      return token.toLowerCase() === currency.id.toLowerCase();
+    });
+
+    if (!subAccount) {
+      throw new Error(
+        "token account '" +
+          token +
+          "' not found. Available: " +
+          subAccounts.map((t) => t.id).join("\n")
+      );
+    }
+
+    return subAccount;
+  });
+}
+
+function inferTransactions(
+  transactions: Array<{ account: AccountLike; transaction: Transaction }>,
+  opts: Record<string, any>
+): Transaction[] {
+  return flatMap(transactions, ({ transaction, account }) => {
+    if (transaction.family !== "cardano") {
+      throw new Error("transaction is not of type cardano");
+    }
+
+    if (account.type === "Account" && !account.cardanoResources) {
+      throw new Error("unactivated account");
+    }
+
+    return {
+      ...transaction,
+      mode: opts.mode || "send",
+      subAccountId: account.type === "TokenAccount" ? account.id : undefined,
+    };
+  });
+}
+
+export default {
+  options,
+  inferAccounts,
+  inferTransactions,
+};

package/src/families/cardano/constants.ts

@@ -0,0 +1,12 @@
+import { getEnv } from "../../env";
+
+export const STAKING_ADDRESS_INDEX = 0;
+export const TTL_GAP = 7200;
+export const CARDANO_PURPOSE = 1852;
+export const CARDANO_COIN_TYPE = 1815;
+export const MEMO_LABEL = 674;
+
+export const CARDANO_API_ENDPOINT = getEnv("CARDANO_API_ENDPOINT");
+export const CARDANO_TESTNET_API_ENDPOINT = getEnv(
+  "CARDANO_TESTNET_API_ENDPOINT"
+);

package/src/families/cardano/datasets/rawAccount.1.ts

@@ -0,0 +1,28 @@
+import { AccountRaw } from "../../../types";
+
+export const cardanoRawAccount1: AccountRaw = {
+  id: "js:2:cardano_testnet:a902bc61a79256e1d5858d2ba49cab7011a26ad49580daace7412e255e818b1c1eba2defa321ff2937deba397f639f5bbabb0f0064516301fa4d08663c83f5b2:",
+  seedIdentifier:
+    "a902bc61a79256e1d5858d2ba49cab7011a26ad49580daace7412e255e818b1c1eba2defa321ff2937deba397f639f5bbabb0f0064516301fa4d08663c83f5b2",
+  name: "Cardano (Testnet) legacy a902bc61...3c83f5b2",
+  derivationMode: "",
+  index: 0,
+  freshAddress:
+    "addr_test1qqllvql2yldah5rsfafafmxu80lx6stlc965ad8fecr8pfz3krjmh2m86v92yu0my7rqydx3h5erqwty82kwgjuc4els8n93zs",
+  freshAddressPath: "1852'/1815'/0'/0/2",
+  freshAddresses: [
+    {
+      address:
+        "addr_test1qqllvql2yldah5rsfafafmxu80lx6stlc965ad8fecr8pfz3krjmh2m86v92yu0my7rqydx3h5erqwty82kwgjuc4els8n93zs",
+      derivationPath: "1852'/1815'/0'/0/2",
+    },
+  ],
+  blockHeight: 0,
+  operations: [],
+  pendingOperations: [],
+  currencyId: "cardano_testnet",
+  unitMagnitude: 6,
+  lastSyncDate: "",
+  balance: "1021211139",
+  xpub: "a902bc61a79256e1d5858d2ba49cab7011a26ad49580daace7412e255e818b1c1eba2defa321ff2937deba397f639f5bbabb0f0064516301fa4d08663c83f5b2",
+};