@ledgerhq/live-common 22.3.0-universal.0 → 23.0.0-next.1

package/src/families/cardano/logic.ts

@@ -0,0 +1,454 @@
+import {
+  CARDANO_COIN_TYPE,
+  CARDANO_PURPOSE,
+  MEMO_LABEL,
+  STAKING_ADDRESS_INDEX,
+  TTL_GAP,
+} from "./constants";
+
+import {
+  utils as TyphonUtils,
+  types as TyphonTypes,
+  address as TyphonAddress,
+} from "@stricahq/typhonjs";
+import {
+  AddressType,
+  AssetGroup,
+  TxInput,
+  TxOutput,
+  TxOutputDestination,
+  TxOutputDestinationType,
+} from "@cardano-foundation/ledgerjs-hw-app-cardano";
+import { str_to_path } from "@cardano-foundation/ledgerjs-hw-app-cardano/dist/utils";
+import {
+  BipPath,
+  PaymentChain,
+  PaymentCredential,
+  StakeChain,
+  StakeCredential,
+  Token,
+} from "./types";
+import { Bip32PublicKey } from "@stricahq/bip32ed25519";
+import bs58 from "bs58";
+import BigNumber from "bignumber.js";
+import { getNetworkParameters } from "./networks";
+import { CryptoCurrency, OperationType } from "../../types";
+import groupBy from "lodash/groupBy";
+import { APITransaction } from "./api/api-types";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+
+/**
+ *  returns BipPath object with account, chain and index field for cardano
+ *
+ * @param {string} path
+ */
+export function getBipPathFromString(path: string): BipPath {
+  const regEx = new RegExp(
+    `^${CARDANO_PURPOSE}'/${CARDANO_COIN_TYPE}'/(\\d*)'/([012])/(\\d*)`
+  );
+  const result = path.match(regEx);
+  if (result == null) {
+    throw new Error("Invalid derivation path");
+  }
+  return getBipPath({
+    account: parseInt(result[1]),
+    chain: parseInt(result[2]),
+    index: parseInt(result[3]),
+  });
+}
+
+/**
+ * returns complete bipPath with purpose, coin, account, chain and index for cardano
+ */
+export function getBipPath({
+  account,
+  chain,
+  index,
+}: {
+  account: number;
+  chain: PaymentChain | StakeChain;
+  index: number;
+}): BipPath {
+  return {
+    purpose: CARDANO_PURPOSE,
+    coin: CARDANO_COIN_TYPE,
+    account,
+    chain,
+    index,
+  };
+}
+
+/**
+ * returns bipPathString from account, chain and index for cardano
+ */
+export function getBipPathString({
+  account,
+  chain,
+  index,
+}: {
+  account: number;
+  chain: number;
+  index: number;
+}): string {
+  return `${CARDANO_PURPOSE}'/${CARDANO_COIN_TYPE}'/${account}'/${chain}/${index}`;
+}
+
+export function getExtendedPublicKeyFromHex(keyHex: string): Bip32PublicKey {
+  return Bip32PublicKey.fromBytes(Buffer.from(keyHex, "hex"));
+}
+
+export function getCredentialKey(
+  accountKey: Bip32PublicKey,
+  path: BipPath
+): { key: string; path: BipPath } {
+  const keyBytes = accountKey
+    .derive(path.chain)
+    .derive(path.index)
+    .toPublicKey()
+    .hash();
+  const pubKeyHex = keyBytes.toString("hex");
+  return {
+    key: pubKeyHex,
+    path,
+  };
+}
+
+/**
+ * returns cardano base address by paymentKey and stakeKey
+ */
+export function getBaseAddress({
+  networkId,
+  paymentCred,
+  stakeCred,
+}: {
+  networkId: number;
+  paymentCred: PaymentCredential;
+  stakeCred: StakeCredential;
+}): TyphonAddress.BaseAddress {
+  const paymentCredential: TyphonTypes.HashCredential = {
+    hash: paymentCred.key,
+    type: TyphonTypes.HashType.ADDRESS,
+    bipPath: paymentCred.path,
+  };
+
+  const stakeCredential: TyphonTypes.HashCredential = {
+    hash: stakeCred.key,
+    type: TyphonTypes.HashType.ADDRESS,
+    bipPath: stakeCred.path,
+  };
+  return new TyphonAddress.BaseAddress(
+    networkId,
+    paymentCredential,
+    stakeCredential
+  );
+}
+
+/**
+ * Returns true if address is a valid
+ *
+ * @param {string} address
+ */
+export const isValidAddress = (address: string, networkId: number): boolean => {
+  if (!address) return false;
+
+  try {
+    // check if it is byron address
+    const addr = bs58.decode(address).toString("hex");
+    if (addr[0] !== "8") {
+      return false;
+    }
+  } catch (error) {
+    try {
+      const hexAddress = TyphonUtils.decodeBech32(address);
+      const addressNetworkId = Number(hexAddress.value.toLowerCase().charAt(1));
+      if (addressNetworkId !== networkId) {
+        return false;
+      }
+    } catch (error) {
+      return false;
+    }
+  }
+  return true;
+};
+
+export const getAbsoluteSlot = function (
+  networkName: string,
+  time: Date
+): number {
+  const networkParams = getNetworkParameters(networkName);
+  const byronChainEndSlots =
+    networkParams.shelleyStartEpoch * networkParams.byronSlotsPerEpoch;
+  const byronChainEndTime =
+    byronChainEndSlots * networkParams.byronSlotDuration;
+
+  const shelleyChainTime =
+    time.getTime() - networkParams.chainStartTime - byronChainEndTime;
+  const shelleyChainSlots = Math.floor(
+    shelleyChainTime / networkParams.shelleySlotDuration
+  );
+  return byronChainEndSlots + shelleyChainSlots;
+};
+
+/**
+ * Returns the time to live for transaction
+ *
+ * @returns {number}
+ */
+export function getTTL(networkName: string): number {
+  return getAbsoluteSlot(networkName, new Date()) + TTL_GAP;
+}
+
+export function getEpoch(networkName: string, time: Date): number {
+  const networkParams = getNetworkParameters(networkName);
+  const chainTime = time.getTime() - networkParams.chainStartTime;
+  const epoch = Math.floor(
+    chainTime /
+      (networkParams.shelleySlotsPerEpoch * networkParams.shelleySlotDuration)
+  );
+  return epoch;
+}
+
+export function mergeTokens(
+  tokens: Array<TyphonTypes.Token>
+): Array<TyphonTypes.Token> {
+  return Object.values(
+    groupBy(tokens, (t) => `${t.policyId}${t.assetName}`)
+  ).map((similarTokens) => ({
+    policyId: similarTokens[0].policyId,
+    assetName: similarTokens[0].assetName,
+    amount: similarTokens.reduce(
+      (total, token) => total.plus(token.amount),
+      new BigNumber(0)
+    ),
+  }));
+}
+
+/**
+ * @param { Array<TyphonTypes.Token> } b
+ * @param { Array<TyphonTypes.Token> } a
+ * @returns a - b
+ */
+export function getTokenDiff(
+  a: Array<TyphonTypes.Token>,
+  b: Array<TyphonTypes.Token>
+): Array<TyphonTypes.Token> {
+  return mergeTokens(
+    a.concat(b.map((t) => ({ ...t, amount: t.amount.negated() })))
+  ).filter((t) => !t.amount.eq(0));
+}
+
+/**
+ * returns the formatted transactionOutput for ledger cardano app
+ *
+ * @param output
+ * @param accountIndex
+ * @returns {TxOutput}
+ */
+export function prepareLedgerOutput(
+  output: TyphonTypes.Output,
+  accountIndex: number
+): TxOutput {
+  const isByronAddress = output.address instanceof TyphonAddress.ByronAddress;
+  let isDeviceOwnedAddress = false;
+  let destination: TxOutputDestination;
+
+  if (!isByronAddress) {
+    const address = output.address as TyphonTypes.ShelleyAddress;
+    isDeviceOwnedAddress =
+      address.paymentCredential &&
+      address.paymentCredential.type === TyphonTypes.HashType.ADDRESS &&
+      address.paymentCredential.bipPath !== undefined;
+  }
+
+  if (isDeviceOwnedAddress) {
+    const address = output.address as TyphonAddress.BaseAddress;
+
+    const paymentKeyPath = (
+      address.paymentCredential as TyphonTypes.HashCredential
+    ).bipPath as TyphonTypes.BipPath;
+    const stakingKeyPath = (
+      address.stakeCredential as TyphonTypes.HashCredential
+    ).bipPath as TyphonTypes.BipPath;
+
+    const paymentKeyPathString = getBipPathString({
+      account: accountIndex,
+      chain: paymentKeyPath.chain,
+      index: paymentKeyPath.index,
+    });
+    const stakingKeyPathString = getBipPathString({
+      account: accountIndex,
+      chain: stakingKeyPath.chain,
+      index: stakingKeyPath.index,
+    });
+
+    destination = {
+      type: TxOutputDestinationType.DEVICE_OWNED,
+      params: {
+        type: AddressType.BASE_PAYMENT_KEY_STAKE_KEY,
+        params: {
+          spendingPath: str_to_path(paymentKeyPathString),
+          stakingPath: str_to_path(stakingKeyPathString),
+        },
+      },
+    };
+  } else {
+    const address = output.address;
+    destination = {
+      type: TxOutputDestinationType.THIRD_PARTY,
+      params: {
+        addressHex: address.getHex(),
+      },
+    };
+  }
+
+  const tokenBundle: Array<AssetGroup> = Object.values(
+    groupBy(output.tokens, ({ policyId }) => policyId)
+  ).map((tokens) => ({
+    policyIdHex: tokens[0].policyId,
+    tokens: tokens.map((token) => ({
+      assetNameHex: token.assetName,
+      amount: token.amount.toString(),
+    })),
+  }));
+
+  return {
+    amount: output.amount.toString(),
+    destination,
+    tokenBundle,
+  };
+}
+
+/**
+ * returns the formatted transactionInput for ledger cardano app
+ *
+ * @param {TyphonTypes.Input} input
+ * @param {number} accountIndex
+ * @returns {TxInput}
+ */
+export function prepareLedgerInput(
+  input: TyphonTypes.Input,
+  accountIndex: number
+): TxInput {
+  const paymentKeyPath =
+    input.address.paymentCredential.type === TyphonTypes.HashType.ADDRESS
+      ? input.address.paymentCredential.bipPath
+      : undefined;
+  return {
+    txHashHex: input.txId,
+    outputIndex: input.index,
+    path: paymentKeyPath
+      ? str_to_path(
+          getBipPathString({
+            account: accountIndex,
+            chain: paymentKeyPath.chain,
+            index: paymentKeyPath.index,
+          })
+        )
+      : null,
+  };
+}
+
+export function getAccountStakeCredential(
+  xpub: string,
+  index: number
+): StakeCredential {
+  const accountXPubKey = getExtendedPublicKeyFromHex(xpub);
+  const keyPath = getCredentialKey(
+    accountXPubKey,
+    getBipPath({
+      account: index,
+      chain: StakeChain.stake,
+      index: STAKING_ADDRESS_INDEX,
+    })
+  );
+  return {
+    key: keyPath.key,
+    path: keyPath.path,
+  };
+}
+
+export function getOperationType({
+  valueChange,
+  fees,
+}: {
+  valueChange: BigNumber;
+  fees: BigNumber;
+}): OperationType {
+  return valueChange.isNegative()
+    ? valueChange.absoluteValue().eq(fees)
+      ? "FEES"
+      : "OUT"
+    : valueChange.isPositive()
+    ? "IN"
+    : "NONE";
+}
+
+export function isTestnet(currency: CryptoCurrency): boolean {
+  return getCryptoCurrencyById(currency.id).isTestnetFor ? true : false;
+}
+
+export function getAccountChange(
+  t: APITransaction,
+  accountCredentialsMap: Record<string, PaymentCredential>
+): { ada: BigNumber; tokens: Array<Token> } {
+  let accountInputAda = new BigNumber(0);
+  const accountInputTokens: Array<Token> = [];
+  t.inputs.forEach((i) => {
+    if (accountCredentialsMap[i.paymentKey]) {
+      accountInputAda = accountInputAda.plus(i.value);
+      accountInputTokens.push(
+        ...i.tokens.map((t) => ({
+          assetName: t.assetName,
+          policyId: t.policyId,
+          amount: new BigNumber(t.value),
+        }))
+      );
+    }
+  });
+
+  let accountOutputAda = new BigNumber(0);
+  const accountOutputTokens: Array<Token> = [];
+  t.outputs.forEach((o) => {
+    if (accountCredentialsMap[o.paymentKey]) {
+      accountOutputAda = accountOutputAda.plus(o.value);
+      accountOutputTokens.push(
+        ...o.tokens.map((t) => ({
+          assetName: t.assetName,
+          policyId: t.policyId,
+          amount: new BigNumber(t.value),
+        }))
+      );
+    }
+  });
+
+  return {
+    ada: accountOutputAda.minus(accountInputAda),
+    tokens: getTokenDiff(accountOutputTokens, accountInputTokens),
+  };
+}
+
+export function getMemoFromTx(tx: APITransaction): string | undefined {
+  let memo;
+  const metadataValue = tx.metadata?.data.find(
+    (m) => m.label === MEMO_LABEL.toString()
+  );
+  if (metadataValue) {
+    try {
+      const parsedValue = JSON.parse(metadataValue.value);
+      if (
+        parsedValue.msg &&
+        Array.isArray(parsedValue.msg) &&
+        parsedValue.msg.length
+      ) {
+        memo = parsedValue.msg.join(", ");
+      }
+      // eslint-disable-next-line no-empty
+    } catch (e) {}
+  }
+  return memo;
+}
+
+export function isHexString(value: string): boolean {
+  const regExp = /^[0-9a-fA-F]+$/;
+  return regExp.test(value);
+}

package/src/families/cardano/networks.ts

@@ -0,0 +1,33 @@
+import type { CardanoLikeNetworkParameters } from "./types";
+
+export const getNetworkParameters = (
+  networkName: string
+): CardanoLikeNetworkParameters => {
+  if (networkName === "cardano") {
+    return {
+      identifier: "cardano",
+      networkId: 1,
+      chainStartTime: 1506203091000,
+      byronSlotDuration: 20000,
+      byronSlotsPerEpoch: 21600,
+      shelleyStartEpoch: 208,
+      shelleySlotDuration: 1000,
+      shelleySlotsPerEpoch: 432000,
+      addressPrefix: "addr",
+    };
+  } else if (networkName === "cardano_testnet") {
+    return {
+      identifier: "cardano_testnet",
+      networkId: 0,
+      chainStartTime: 1563999616000,
+      byronSlotDuration: 20000,
+      byronSlotsPerEpoch: 21600,
+      shelleyStartEpoch: 74,
+      shelleySlotDuration: 1000,
+      shelleySlotsPerEpoch: 432000,
+      addressPrefix: "addr_test",
+    };
+  }
+
+  throw new Error("No network parameters set for " + networkName);
+};

package/src/families/cardano/postSyncPatch.ts

@@ -0,0 +1,45 @@
+/**
+ *  Code reference taken from src/families/ethereum/postSyncPatch.ts
+ */
+
+import type { AccountLike, Account, Operation } from "../../types";
+
+// we need to preserve ADA pendingOperations because there is no mempool to do this
+// we assume we need to preserve until:
+// - that txid appears in operations
+const postSyncPatchGen = <T extends AccountLike>(
+  initial: T,
+  synced: T,
+  parentPendingOperation?: Operation[]
+): T => {
+  const pendingOperations = initial.pendingOperations || [];
+  if (pendingOperations.length === 0) return synced;
+  const { operations } = synced;
+  synced.pendingOperations = pendingOperations.filter(
+    (op) =>
+      (!parentPendingOperation || // a child pending parent need to disappear if parent ada op disappear
+        parentPendingOperation.some((o) => o.hash === op.hash)) &&
+      !operations.some((o) => o.hash === op.hash) // after retain logic, we need operation to appear
+  );
+  return synced;
+};
+
+const postSyncPatch = (initial: Account, synced: Account): Account => {
+  const acc = postSyncPatchGen(initial, synced);
+  const { subAccounts, pendingOperations } = acc;
+  const initialSubAccounts = initial.subAccounts;
+
+  if (subAccounts && initialSubAccounts) {
+    acc.subAccounts = subAccounts.map((subAccount) => {
+      const initialSubAccount = initialSubAccounts.find(
+        (a) => a.id === subAccount.id
+      );
+      if (!initialSubAccount) return subAccount;
+      return postSyncPatchGen(initialSubAccount, subAccount, pendingOperations);
+    });
+  }
+
+  return acc;
+};
+
+export default postSyncPatch;

package/src/families/cardano/serialization.ts

@@ -0,0 +1,179 @@
+import { BigNumber } from "bignumber.js";
+import type {
+  BipPath,
+  BipPathRaw,
+  CardanoOutput,
+  CardanoOutputRaw,
+  CardanoResources,
+  CardanoResourcesRaw,
+  PaymentCredential,
+  PaymentCredentialRaw,
+  ProtocolParams,
+  ProtocolParamsRaw,
+  Token,
+  TokenRaw,
+} from "./types";
+
+function toTokenRaw({ assetName, policyId, amount }: Token): TokenRaw {
+  return {
+    assetName,
+    policyId,
+    amount: amount.toString(),
+  };
+}
+
+function fromTokenRaw({ assetName, policyId, amount }: TokenRaw): Token {
+  return {
+    assetName,
+    policyId,
+    amount: new BigNumber(amount),
+  };
+}
+
+function toBipPathRaw({
+  purpose,
+  coin,
+  account,
+  chain,
+  index,
+}: BipPath): BipPathRaw {
+  return {
+    purpose,
+    coin,
+    account,
+    chain,
+    index,
+  };
+}
+
+function fromBipPathRaw({
+  purpose,
+  coin,
+  account,
+  chain,
+  index,
+}: BipPathRaw): BipPath {
+  return {
+    purpose,
+    coin,
+    account,
+    chain,
+    index,
+  };
+}
+
+function toPaymentCredentialRaw(r: PaymentCredential): PaymentCredentialRaw {
+  return {
+    isUsed: r.isUsed,
+    key: r.key,
+    path: toBipPathRaw(r.path),
+  };
+}
+
+function fromPaymentCredentialRaw(r: PaymentCredentialRaw): PaymentCredential {
+  return {
+    isUsed: r.isUsed,
+    key: r.key,
+    path: fromBipPathRaw(r.path),
+  };
+}
+
+function toCardanoOutputRaw({
+  hash,
+  index,
+  address,
+  amount,
+  tokens,
+  paymentCredential,
+}: CardanoOutput): CardanoOutputRaw {
+  return {
+    hash,
+    index,
+    address,
+    amount: amount.toString(),
+    tokens: tokens.map(toTokenRaw),
+    paymentCredential,
+  };
+}
+
+function fromCardanoOutputRaw({
+  hash,
+  index,
+  address,
+  amount,
+  tokens,
+  paymentCredential,
+}: CardanoOutputRaw): CardanoOutput {
+  return {
+    hash,
+    index,
+    address,
+    amount: new BigNumber(amount),
+    tokens: tokens.map(fromTokenRaw),
+    paymentCredential,
+  };
+}
+
+function toProtocolParamsRaw({
+  minFeeA,
+  minFeeB,
+  stakeKeyDeposit,
+  lovelacePerUtxoWord,
+  collateralPercent,
+  priceSteps,
+  priceMem,
+  languageView,
+}: ProtocolParams): ProtocolParamsRaw {
+  return {
+    minFeeA,
+    minFeeB,
+    stakeKeyDeposit,
+    lovelacePerUtxoWord,
+    collateralPercent,
+    priceSteps,
+    priceMem,
+    languageView,
+  };
+}
+
+function fromProtocolParamsRaw({
+  minFeeA,
+  minFeeB,
+  stakeKeyDeposit,
+  lovelacePerUtxoWord,
+  collateralPercent,
+  priceSteps,
+  priceMem,
+  languageView,
+}: ProtocolParamsRaw): ProtocolParams {
+  return {
+    minFeeA,
+    minFeeB,
+    stakeKeyDeposit,
+    lovelacePerUtxoWord,
+    collateralPercent,
+    priceSteps,
+    priceMem,
+    languageView,
+  };
+}
+
+export function toCardanoResourceRaw(r: CardanoResources): CardanoResourcesRaw {
+  return {
+    internalCredentials: r.internalCredentials.map(toPaymentCredentialRaw),
+    externalCredentials: r.externalCredentials.map(toPaymentCredentialRaw),
+    utxos: r.utxos.map(toCardanoOutputRaw),
+    protocolParams: toProtocolParamsRaw(r.protocolParams),
+  };
+}
+
+export function fromCardanoResourceRaw(
+  r: CardanoResourcesRaw
+): CardanoResources {
+  return {
+    internalCredentials: r.internalCredentials.map(fromPaymentCredentialRaw),
+    externalCredentials: r.externalCredentials.map(fromPaymentCredentialRaw),
+    utxos: r.utxos.map(fromCardanoOutputRaw),
+    protocolParams: fromProtocolParamsRaw(r.protocolParams),
+  };
+}