@ledgerhq/live-common 34.2.0 → 34.3.0-next.0

package/src/families/cardano/buildSubAccounts.ts

@@ -1,167 +0,0 @@
-import BigNumber from "bignumber.js";
-import { encodeOperationId } from "../../operation";
-import { APITransaction } from "./api/api-types";
-import { getAccountChange, getMemoFromTx, isHexString } from "./logic";
-import { CardanoOperation, CardanoOperationExtra, PaymentCredential, Token } from "./types";
-import { utils as TyphonUtils } from "@stricahq/typhonjs";
-import { findTokenById } from "@ledgerhq/cryptoassets";
-import { decodeTokenAccountId, emptyHistoryCache, encodeTokenAccountId } from "../../account";
-import groupBy from "lodash/groupBy";
-import keyBy from "lodash/keyBy";
-import { mergeOps } from "../../bridge/jsHelpers";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import type { Account, TokenAccount } from "@ledgerhq/types-live";
-
-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<CardanoOperation> => {
-  const operations: Array<CardanoOperation> = [];
-
-  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 extra: CardanoOperationExtra = {};
-      if (memo) {
-        extra.memo = memo;
-      }
-      const operation: CardanoOperation = {
-        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,
-        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<CardanoOperation> = 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

@@ -1,81 +0,0 @@
-import { Account, AccountLike } from "@ledgerhq/types-live";
-import invariant from "invariant";
-import flatMap from "lodash/flatMap";
-import { getAccountCurrency } from "../../account";
-import { TokenAccount } from "../solana/api/chain/account/token";
-import { CardanoAccount, Transaction } from "./types";
-
-const options = [
-  {
-    name: "mode",
-    type: String,
-    desc: "mode of transaction: send, delegate, undelegate",
-  },
-  {
-    name: "token",
-    type: String,
-    desc: "uses subAccount(TokenAccount) of the account",
-  },
-  {
-    name: "poolId",
-    type: String,
-    desc: "Cardano stake pool id to delegate",
-  },
-];
-
-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 as CardanoAccount).cardanoResources) {
-      throw new Error("unactivated account");
-    }
-
-    return {
-      ...transaction,
-      mode: opts.mode || "send",
-      subAccountId: account.type === "TokenAccount" ? account.id : undefined,
-      poolId: opts.poolId || "",
-    };
-  });
-}
-
-export default {
-  options,
-  inferAccounts,
-  inferTransactions,
-};

package/src/families/cardano/constants.ts

@@ -1,10 +0,0 @@
-import { getEnv } from "@ledgerhq/live-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

@@ -1,27 +0,0 @@
-import type { AccountRaw } from "@ledgerhq/types-live";
-
-export const cardanoRawAccount1: AccountRaw = {
-  id: "js:2:cardano_testnet:806499588e0c4a58f4119f7e6e096bf42c3f774a528d2acec9e82ceebf87d1ceb3d4f3622dd2c77c65cc89c123f79337db22cf8a69f122e36dab1bf5083bf82d:cardano",
-  seedIdentifier: "bea94629d5cf776b8374a00afa15686f0b0742dd0330f86804c61202",
-  name: "Cardano (Testnet) 1",
-  derivationMode: "cardano",
-  index: 0,
-  freshAddress:
-    "addr_test1qpj84xm4jlpcsvmrnldj86zz7g4mwzr7qg90wdjpn64uea44mcsd3mzvmr9qhfscxkyla3aqnzttwepay9mt3fz84smqyjvhh4",
-  freshAddressPath: "1852'/1815'/0'/0/2",
-  freshAddresses: [
-    {
-      derivationPath: "1852'/1815'/0'/0/2",
-      address:
-        "addr_test1qpj84xm4jlpcsvmrnldj86zz7g4mwzr7qg90wdjpn64uea44mcsd3mzvmr9qhfscxkyla3aqnzttwepay9mt3fz84smqyjvhh4",
-    },
-  ],
-  blockHeight: 0,
-  operations: [],
-  pendingOperations: [],
-  currencyId: "cardano_testnet",
-  unitMagnitude: 6,
-  lastSyncDate: "",
-  balance: "10098829375",
-  xpub: "806499588e0c4a58f4119f7e6e096bf42c3f774a528d2acec9e82ceebf87d1ceb3d4f3622dd2c77c65cc89c123f79337db22cf8a69f122e36dab1bf5083bf82d",
-};

package/src/families/cardano/datasets/scanAccounts.ts

@@ -1,23 +0,0 @@
-export const cardanoScanAccounts = [
-  {
-    name: "cardano_testnet seed 1",
-    apdus: `
-    => d700000000
-    <= 050000009000
-    => d71101002d0000058000073c8000071780000000000000000000000022058000073c80000717800000000000000200000000
-    <= 00bea94629d5cf776b8374a00afa15686f0b0742dd0330f86804c61202b5de20d8ec4cd8ca0ba6183589fec7a09896b7643d2176b8a447ac369000
-    => d700000000
-    <= 050000009000
-    => d71000000d038000073c8000071780000000
-    <= 806499588e0c4a58f4119f7e6e096bf42c3f774a528d2acec9e82ceebf87d1ceb3d4f3622dd2c77c65cc89c123f79337db22cf8a69f122e36dab1bf5083bf82d9000
-    => d700000000
-    <= 050000009000
-    => d71101002d0000058000073c8000071780000001000000000000000022058000073c80000717800000010000000200000000
-    <= 0009457d98f405191765830c1afe91cc32b5f45c193a9aad4b606f8f5dd599d97135c125c5633d3d4431be87a9cff26ec08d388833bfcc530f9000
-    => d700000000
-    <= 050000009000
-    => d71000000d038000073c8000071780000001
-    <= ed5e0d059cb2eed53ea30b9ba84bb3aaa6c2364c6305a0c9a7e8944aa439884a642cc2f06e601808926e14b6e27417be0b0323d5a5149f1eebab8fc4e1fe14d49000
-    `,
-  },
-];

package/src/families/cardano/deviceTransactionConfig.ts

@@ -1,124 +0,0 @@
-import BigNumber from "bignumber.js";
-import { getAccountUnit, getMainAccount } from "../../account";
-import { formatCurrencyUnit } from "../../currencies";
-import { DeviceTransactionField } from "../../transaction";
-import { Account, AccountLike } from "@ledgerhq/types-live";
-import { decodeTokenAssetId, decodeTokenCurrencyId } from "./buildSubAccounts";
-import { CardanoAccount, Transaction, TransactionStatus } from "./types";
-import { utils as TyphonUtils } from "@stricahq/typhonjs";
-import {
-  decodeTokenName,
-  getAccountStakeCredential,
-  getBech32PoolId,
-  getBipPathString,
-} from "./logic";
-
-function getDeviceTransactionConfig({
-  account,
-  transaction,
-  parentAccount,
-}: {
-  account: AccountLike;
-  parentAccount: Account | null | undefined;
-  transaction: Transaction;
-  status: TransactionStatus;
-}): Array<DeviceTransactionField> {
-  const { mode } = transaction;
-  const fields: DeviceTransactionField[] = [];
-  const mainAccount = getMainAccount(account, parentAccount);
-  const cardanoResources = (mainAccount as CardanoAccount).cardanoResources;
-
-  const { fees } = transaction;
-  if (fees) {
-    fields.push({
-      type: "text",
-      label: "Transaction Fee",
-      value: formatCurrencyUnit(getAccountUnit(account), fees, {
-        showCode: true,
-        disableRounding: true,
-      }),
-    });
-  }
-
-  if (mode === "send") {
-    if (account.type === "TokenAccount") {
-      const { assetId } = decodeTokenCurrencyId(account.token.id);
-      const { policyId, assetName } = decodeTokenAssetId(assetId);
-      const transactionAmount = transaction.useAllAmount ? account.balance : transaction.amount;
-
-      const tokensToSend = [
-        {
-          policyId,
-          assetName,
-          amount: transactionAmount,
-        },
-      ];
-
-      const requiredMinAdaForTokens = TyphonUtils.calculateMinUtxoAmount(
-        tokensToSend,
-        new BigNumber(cardanoResources.protocolParams.lovelacePerUtxoWord),
-      );
-      fields.push({
-        type: "text",
-        label: "ADA",
-        value: formatCurrencyUnit(getAccountUnit(mainAccount), requiredMinAdaForTokens, {
-          showCode: true,
-          disableRounding: true,
-        }),
-      });
-      fields.push({
-        type: "text",
-        label: "Token Name",
-        value: decodeTokenName(assetName),
-      });
-      fields.push({
-        type: "text",
-        label: "Amount",
-        value: formatCurrencyUnit(getAccountUnit(account), transactionAmount, {
-          showCode: true,
-          disableRounding: true,
-        }),
-      });
-    } else if (account.type === "Account") {
-      fields.push({
-        type: "text",
-        label: "Amount",
-        value: formatCurrencyUnit(getAccountUnit(account), transaction.amount, {
-          showCode: true,
-          disableRounding: true,
-        }),
-      });
-    }
-  } else if (mode === "delegate" && account.type === "Account") {
-    const stakeCredential = getAccountStakeCredential(account.xpub as string, account.index);
-    fields.push({
-      type: "text",
-      label: "Staking key",
-      value: getBipPathString({
-        account: stakeCredential.path.account,
-        chain: stakeCredential.path.chain,
-        index: stakeCredential.path.index,
-      }),
-    });
-    fields.push({
-      type: "text",
-      label: "Delegate stake to",
-      value: getBech32PoolId(transaction.poolId as string, account.currency.id),
-    });
-  } else if (mode === "undelegate" && account.type === "Account") {
-    const stakeCredential = getAccountStakeCredential(account.xpub as string, account.index);
-    fields.push({
-      type: "text",
-      label: "Staking key",
-      value: getBipPathString({
-        account: stakeCredential.path.account,
-        chain: stakeCredential.path.chain,
-        index: stakeCredential.path.index,
-      }),
-    });
-  }
-
-  return fields;
-}
-
-export default getDeviceTransactionConfig;

package/src/families/cardano/errors.ts

@@ -1,18 +0,0 @@
-import { createCustomErrorClass } from "@ledgerhq/errors";
-
-/**
- * Cardano error thrown when transaction amount is less then minUtxo
- */
-export const CardanoMinAmountError = createCustomErrorClass("CardanoMinAmountError");
-
-/**
- * Cardano error thrown when user don't have enough fund for deposit
- */
-export const CardanoStakeKeyDepositError = createCustomErrorClass("CardanoStakeKeyDepositError");
-
-/**
- * Cardano error thrown when not enough funds to perform transaction
- */
-export const CardanoNotEnoughFunds = createCustomErrorClass("CardanoNotEnoughFunds");
-
-export const CardanoInvalidPoolId = createCustomErrorClass("CardanoInvalidPoolId");

package/src/families/cardano/hw-getAddress.ts

@@ -1,54 +0,0 @@
-import type { Resolver } from "../../hw/getAddress/types";
-import Ada, { Networks, AddressType } from "@cardano-foundation/ledgerjs-hw-app-cardano";
-import { str_to_path } from "@cardano-foundation/ledgerjs-hw-app-cardano/dist/utils/address";
-import { getBipPathFromString, getBipPathString } from "./logic";
-import { StakeChain } from "./types";
-import { STAKING_ADDRESS_INDEX } from "./constants";
-import { utils as TyphonUtils } from "@stricahq/typhonjs";
-import { address as TyphonAddress } from "@stricahq/typhonjs";
-import { getNetworkParameters } from "./networks";
-
-const resolver: Resolver = async (transport, { path, verify, currency }) => {
-  const spendingPath = getBipPathFromString(path);
-  const stakingPathString = getBipPathString({
-    account: spendingPath.account,
-    chain: StakeChain.stake,
-    index: STAKING_ADDRESS_INDEX,
-  });
-  const networkParams = getNetworkParameters(currency.id);
-  const network =
-    networkParams.networkId === Networks.Mainnet.networkId ? Networks.Mainnet : Networks.Testnet;
-
-  const ada = new Ada(transport);
-  const r = await ada.deriveAddress({
-    network,
-    address: {
-      type: AddressType.BASE_PAYMENT_KEY_STAKE_KEY,
-      params: {
-        spendingPath: str_to_path(path),
-        stakingPath: str_to_path(stakingPathString),
-      },
-    },
-  });
-  if (verify) {
-    await ada.showAddress({
-      network,
-      address: {
-        type: AddressType.BASE_PAYMENT_KEY_STAKE_KEY,
-        params: {
-          spendingPath: str_to_path(path),
-          stakingPath: str_to_path(stakingPathString),
-        },
-      },
-    });
-  }
-  const address = TyphonUtils.getAddressFromHex(r.addressHex) as TyphonAddress.BaseAddress;
-  return {
-    address: address.getBech32(),
-    // Here, we use publicKey hash, as cardano app doesn't export the public key
-    publicKey: address.paymentCredential.hash,
-    path,
-  };
-};
-
-export default resolver;

package/src/families/cardano/js-broadcast.ts

@@ -1,19 +0,0 @@
-import type { BroadcastFnSignature } from "@ledgerhq/types-live";
-import { patchOperationWithHash } from "../../operation";
-import { submitTransaction } from "./api/submitTransaction";
-
-/**
- * Broadcast the signed transaction
- * @param {signature: string, operation: string} signedOperation
- */
-const broadcast: BroadcastFnSignature = async ({ signedOperation, account }) => {
-  const signedTx = signedOperation.signature;
-  const pendingTransaction = await submitTransaction({
-    transaction: signedTx,
-    currency: account.currency,
-  });
-
-  return patchOperationWithHash(signedOperation.operation, pendingTransaction.hash);
-};
-
-export default broadcast;