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

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

@@ -0,0 +1,265 @@
+import { BigNumber } from "bignumber.js";
+import { Observable } from "rxjs";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+
+import type { CardanoResources, Transaction } from "./types";
+import type {
+  Account,
+  Operation,
+  SignedOperation,
+  SignOperationEvent,
+} from "../../types";
+
+import { withDevice } from "../../hw/deviceAccess";
+import { encodeOperationId } from "../../operation";
+
+import { buildTransaction } from "./js-buildTransaction";
+
+import Ada, {
+  Networks,
+  SignTransactionRequest,
+  TransactionSigningMode,
+  TxAuxiliaryDataType,
+  Witness,
+} from "@cardano-foundation/ledgerjs-hw-app-cardano";
+import {
+  types as TyphonTypes,
+  Transaction as TyphonTransaction,
+} from "@stricahq/typhonjs";
+import { Bip32PublicKey } from "@stricahq/bip32ed25519";
+import {
+  getExtendedPublicKeyFromHex,
+  getOperationType,
+  prepareLedgerInput,
+  prepareLedgerOutput,
+} from "./logic";
+import ShelleyTypeAddress from "@stricahq/typhonjs/dist/address/ShelleyTypeAddress";
+import { getNetworkParameters } from "./networks";
+import { MEMO_LABEL } from "./constants";
+
+const buildOptimisticOperation = (
+  account: Account,
+  transaction: TyphonTransaction,
+  t: Transaction
+): Operation => {
+  const cardanoResources = account.cardanoResources as CardanoResources;
+  const accountCreds = new Set(
+    [
+      ...cardanoResources.externalCredentials,
+      ...cardanoResources.internalCredentials,
+    ].map((cred) => cred.key)
+  );
+
+  const accountInput = transaction
+    .getInputs()
+    .reduce(
+      (total, i) =>
+        accountCreds.has(i.address.paymentCredential.hash)
+          ? total.plus(i.amount)
+          : total.plus(0),
+      new BigNumber(0)
+    );
+
+  const accountOutput = transaction
+    .getOutputs()
+    .reduce(
+      (total, o) =>
+        o.address instanceof ShelleyTypeAddress &&
+        accountCreds.has(o.address.paymentCredential.hash)
+          ? total.plus(o.amount)
+          : total.plus(0),
+      new BigNumber(0)
+    );
+
+  const accountChange = accountOutput.minus(accountInput);
+  const opType = getOperationType({
+    valueChange: accountChange,
+    fees: transaction.getFee(),
+  });
+  const transactionHash = transaction.getTransactionHash().toString("hex");
+  const auxiliaryData = transaction.getAuxiliaryData();
+  let memo;
+  if (auxiliaryData) {
+    const memoMetadata = auxiliaryData.metadata.find(
+      (m) => m.label === MEMO_LABEL
+    );
+    if (memoMetadata && Array.isArray(memoMetadata.data)) {
+      memo = memoMetadata.data.join(", ");
+    }
+  }
+
+  const op: Operation = {
+    id: encodeOperationId(account.id, transactionHash, opType),
+    hash: transactionHash,
+    type: opType,
+    value: accountChange.absoluteValue(),
+    fee: transaction.getFee(),
+    blockHash: undefined,
+    blockHeight: null,
+    senders: transaction.getInputs().map((i) => i.address.getBech32()),
+    recipients: transaction.getOutputs().map((o) => o.address.getBech32()),
+    accountId: account.id,
+    date: new Date(),
+    extra: {
+      memo,
+    },
+  };
+
+  const tokenAccount = t.subAccountId
+    ? account.subAccounts?.find((ta) => ta.id === t.subAccountId)
+    : null;
+
+  if (tokenAccount && opType === "OUT") {
+    op.subOperations = [
+      {
+        id: encodeOperationId(tokenAccount.id, transactionHash, opType),
+        hash: transactionHash,
+        type: opType,
+        value: t.useAllAmount ? tokenAccount.balance : t.amount,
+        fee: t.fees as BigNumber,
+        blockHash: undefined,
+        blockHeight: null,
+        senders: transaction.getInputs().map((i) => i.address.getBech32()),
+        recipients: transaction.getOutputs().map((o) => o.address.getBech32()),
+        accountId: tokenAccount.id,
+        date: new Date(),
+        extra: {},
+      },
+    ];
+  }
+
+  return op;
+};
+
+/**
+ * Adds signatures to unsigned transaction
+ */
+const signTx = (
+  unsignedTransaction: TyphonTransaction,
+  accountKey: Bip32PublicKey,
+  witnesses: Array<Witness>
+) => {
+  witnesses.forEach((witness) => {
+    const [, , , chainType, index] = witness.path;
+    const publicKey = accountKey
+      .derive(chainType)
+      .derive(index)
+      .toPublicKey()
+      .toBytes();
+    const vKeyWitness: TyphonTypes.VKeyWitness = {
+      signature: Buffer.from(witness.witnessSignatureHex, "hex"),
+      publicKey: Buffer.from(publicKey),
+    };
+    unsignedTransaction.addWitness(vKeyWitness);
+  });
+
+  return unsignedTransaction.buildTransaction();
+};
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+const signOperation = ({
+  account,
+  deviceId,
+  transaction,
+}: {
+  account: Account;
+  deviceId: string;
+  transaction: Transaction;
+}): Observable<SignOperationEvent> =>
+  withDevice(deviceId)(
+    (transport) =>
+      new Observable((o) => {
+        async function main() {
+          o.next({ type: "device-signature-requested" });
+
+          if (!transaction.fees) {
+            throw new FeeNotLoaded();
+          }
+
+          const unsignedTransaction = await buildTransaction(
+            account,
+            transaction
+          );
+
+          const accountPubKey = getExtendedPublicKeyFromHex(
+            account.xpub as string
+          );
+
+          const rawInputs = unsignedTransaction.getInputs();
+          const ledgerAppInputs = rawInputs.map((i) =>
+            prepareLedgerInput(i, account.index)
+          );
+
+          const rawOutptus = unsignedTransaction.getOutputs();
+          const ledgerAppOutputs = rawOutptus.map((o) =>
+            prepareLedgerOutput(o, account.index)
+          );
+
+          const auxiliaryDataHashHex =
+            unsignedTransaction.getAuxiliaryDataHashHex();
+
+          const networkParams = getNetworkParameters(account.currency.id);
+          const network =
+            networkParams.networkId === Networks.Mainnet.networkId
+              ? Networks.Mainnet
+              : Networks.Testnet;
+
+          const trxOptions: SignTransactionRequest = {
+            signingMode: TransactionSigningMode.ORDINARY_TRANSACTION,
+            tx: {
+              network,
+              inputs: ledgerAppInputs,
+              outputs: ledgerAppOutputs,
+              certificates: [],
+              withdrawals: [],
+              fee: unsignedTransaction.getFee().toString(),
+              ttl: unsignedTransaction.getTTL()?.toString(),
+              validityIntervalStart: null,
+              auxiliaryData: auxiliaryDataHashHex
+                ? {
+                    type: TxAuxiliaryDataType.ARBITRARY_HASH,
+                    params: {
+                      hashHex: auxiliaryDataHashHex,
+                    },
+                  }
+                : null,
+            },
+            additionalWitnessPaths: [],
+          };
+
+          // Sign by device
+          const appAda = new Ada(transport);
+          const r = await appAda.signTransaction(trxOptions);
+          const signed = signTx(
+            unsignedTransaction,
+            accountPubKey,
+            r.witnesses
+          );
+
+          o.next({ type: "device-signature-granted" });
+
+          const operation = buildOptimisticOperation(
+            account,
+            unsignedTransaction,
+            transaction
+          );
+
+          o.next({
+            type: "signed",
+            signedOperation: {
+              operation,
+              signature: signed.payload,
+              expirationDate: null,
+            } as SignedOperation,
+          });
+        }
+        main().then(
+          () => o.complete(),
+          (e) => o.error(e)
+        );
+      })
+  );
+
+export default signOperation;

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

@@ -0,0 +1,255 @@
+import type { Operation, TokenAccount } from "../../types";
+import {
+  GetAccountShape,
+  makeScanAccounts,
+  mergeOps,
+} from "../../bridge/jsHelpers";
+import { makeSync } from "../../bridge/jsHelpers";
+import { encodeAccountId, inferSubOperations } from "../../account";
+
+import BigNumber from "bignumber.js";
+import Ada from "@cardano-foundation/ledgerjs-hw-app-cardano";
+import { str_to_path } from "@cardano-foundation/ledgerjs-hw-app-cardano/dist/utils";
+import { utils as TyphonUtils } from "@stricahq/typhonjs";
+import { APITransaction } from "./api/api-types";
+import { CardanoOutput, PaymentCredential } from "./types";
+import {
+  getAccountChange,
+  getAccountStakeCredential,
+  getBaseAddress,
+  getBipPathString,
+  getMemoFromTx,
+  getOperationType,
+  isHexString,
+} from "./logic";
+import { encodeOperationId } from "../../operation";
+import { getNetworkParameters } from "./networks";
+import { getNetworkInfo } from "./api/getNetworkInfo";
+import uniqBy from "lodash/uniqBy";
+import postSyncPatch from "./postSyncPatch";
+import { getTransactions } from "./api/getTransactions";
+
+function mapTxToAccountOperation(
+  tx: APITransaction,
+  accountId: string,
+  accountCredentialsMap: Record<string, PaymentCredential>,
+  subAccounts: Array<TokenAccount>
+): Operation {
+  const accountChange = getAccountChange(tx, accountCredentialsMap);
+  const mainOperationType = getOperationType({
+    valueChange: accountChange.ada,
+    fees: new BigNumber(tx.fees),
+  });
+
+  const subOperations = inferSubOperations(tx.hash, subAccounts);
+  const memo = getMemoFromTx(tx);
+
+  return {
+    accountId,
+    id: encodeOperationId(accountId, tx.hash, mainOperationType),
+    hash: tx.hash,
+    type: mainOperationType,
+    fee: new BigNumber(tx.fees),
+    value: accountChange.ada.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
+    ),
+    subOperations,
+    blockHeight: tx.blockHeight,
+    date: new Date(tx.timestamp),
+    extra: {
+      memo,
+    },
+    blockHash: undefined,
+  };
+}
+
+function syncUtxos(
+  newTransactions: Array<APITransaction>,
+  stableUtxos: Array<CardanoOutput>,
+  accountCredentialsMap: Record<string, PaymentCredential>
+): Array<CardanoOutput> {
+  const newUtxos: Array<CardanoOutput> = [];
+  // spentUtxoKey = txId#index
+  const spentUtxoKeys: Set<string> = new Set();
+
+  newTransactions.forEach((t) => {
+    t.inputs.forEach((i) => {
+      const cred = accountCredentialsMap[i.paymentKey];
+      if (cred) spentUtxoKeys.add(`${i.txId}#${i.index}`);
+    });
+
+    t.outputs.forEach((o, outputIndex) => {
+      const cred = accountCredentialsMap[o.paymentKey];
+      if (cred) {
+        newUtxos.push({
+          hash: t.hash,
+          index: outputIndex,
+          address: o.address,
+          amount: new BigNumber(o.value),
+          tokens: o.tokens.map((token) => ({
+            assetName: token.assetName,
+            policyId: token.policyId,
+            amount: new BigNumber(token.value),
+          })),
+          paymentCredential: {
+            key: o.paymentKey,
+            path: cred.path,
+          },
+        });
+      }
+    });
+  });
+
+  const utxos = uniqBy(
+    [...stableUtxos, ...newUtxos],
+    (u) => `${u.hash}#${u.index}`
+  ).filter((u) => !spentUtxoKeys.has(`${u.hash}#${u.index}`));
+
+  return utxos;
+}
+
+export const getAccountShape: GetAccountShape = async (info) => {
+  const {
+    transport,
+    currency,
+    index: accountIndex,
+    derivationPath,
+    derivationMode,
+    initialAccount,
+  } = info;
+  // In case we get a full derivation path
+  const rootPath = derivationPath.split("/", 2).join("/");
+  const accountPath = `${rootPath}/${accountIndex}'`;
+
+  const paramXpub = initialAccount?.xpub;
+  let extendedPubKeyRes;
+  if (!paramXpub) {
+    if (!transport) {
+      // hwapp not provided
+      throw new Error("hwapp required to generate the xpub");
+    }
+    const ada = new Ada(transport);
+    extendedPubKeyRes = await ada.getExtendedPublicKey({
+      path: str_to_path(accountPath),
+    });
+  }
+  const xpub =
+    paramXpub ||
+    `${extendedPubKeyRes.publicKeyHex}${extendedPubKeyRes.chainCodeHex}`;
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: xpub,
+    derivationMode,
+  });
+
+  const requiredConfirmations = 90;
+  const syncFromBlockHeight =
+    initialAccount?.blockHeight &&
+    initialAccount.blockHeight > requiredConfirmations
+      ? initialAccount.blockHeight - requiredConfirmations
+      : 0;
+
+  const {
+    transactions: newTransactions,
+    blockHeight,
+    externalCredentials,
+    internalCredentials,
+  } = await getTransactions(
+    xpub,
+    accountIndex,
+    initialAccount,
+    syncFromBlockHeight,
+    currency
+  );
+
+  const accountCredentialsMap = [
+    ...externalCredentials,
+    ...internalCredentials,
+  ].reduce((finalMap, cred) => {
+    finalMap[cred.key] = cred;
+    return finalMap;
+  }, {} as Record<string, PaymentCredential>);
+
+  const stableOperationsByIds: Record<string, Operation> = {};
+  (initialAccount?.operations || []).forEach((o) => {
+    if ((o.blockHeight as number) < syncFromBlockHeight) {
+      stableOperationsByIds[o.hash] = o;
+    }
+  });
+
+  const stableUtxos = (initialAccount?.cardanoResources?.utxos || []).filter(
+    (u) => stableOperationsByIds[u.hash]
+  );
+
+  const utxos = syncUtxos(newTransactions, stableUtxos, accountCredentialsMap);
+  const accountBalance = utxos.reduce(
+    (total, u) => total.plus(u.amount),
+    new BigNumber(0)
+  );
+  // const tokenBalance = mergeTokens(utxos.map((u) => u.tokens).flat());
+  // const subAccounts = buildSubAccounts({
+  //   initialAccount,
+  //   parentAccountId: accountId,
+  //   parentCurrency: currency,
+  //   newTransactions,
+  //   tokens: tokenBalance,
+  //   accountCredentialsMap,
+  // });
+  const subAccounts = [];
+
+  const newOperations = newTransactions.map((t) =>
+    mapTxToAccountOperation(t, accountId, accountCredentialsMap, subAccounts)
+  );
+
+  const operations = mergeOps(
+    Object.values(stableOperationsByIds),
+    newOperations
+  );
+
+  const stakeCredential = getAccountStakeCredential(xpub, accountIndex);
+  const networkParams = getNetworkParameters(currency.id);
+  const freshAddresses = externalCredentials
+    .filter((c) => !c.isUsed)
+    .map((c) => ({
+      derivationPath: getBipPathString(c.path),
+      address: getBaseAddress({
+        networkId: networkParams.networkId,
+        paymentCred: c,
+        stakeCred: stakeCredential,
+      }).getBech32(),
+    }));
+  const cardanoNetworkInfo = await getNetworkInfo(initialAccount, currency);
+
+  return {
+    id: accountId,
+    xpub,
+    balance: accountBalance,
+    spendableBalance: accountBalance,
+    operations: operations,
+    subAccounts,
+    freshAddresses,
+    freshAddress: freshAddresses[0].address,
+    freshAddressPath: freshAddresses[0].derivationPath,
+    blockHeight,
+    cardanoResources: {
+      utxos,
+      externalCredentials,
+      internalCredentials,
+      protocolParams: cardanoNetworkInfo.protocolParams,
+    },
+  };
+};
+
+export const scanAccounts = makeScanAccounts({ getAccountShape });
+
+export const sync = makeSync({ getAccountShape, postSync: postSyncPatch });

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

@@ -0,0 +1,69 @@
+import { BigNumber } from "bignumber.js";
+import type { Account } from "../../types";
+import { Transaction } from "./types";
+import {
+  types as TyphonTypes,
+  address as TyphonAddress,
+} from "@stricahq/typhonjs";
+
+import { buildTransaction } from "./js-buildTransaction";
+
+/**
+ * Create an empty transaction
+ *
+ * @returns {Transaction}
+ */
+export const createTransaction = (): Transaction => ({
+  family: "cardano",
+  mode: "send",
+  amount: new BigNumber(0),
+  recipient: "",
+  useAllAmount: false,
+  fees: new BigNumber(0),
+});
+
+/**
+ * Apply patch to transaction
+ *
+ * @param {*} t
+ * @param {*} patch
+ */
+export const updateTransaction = (
+  t: Transaction,
+  patch: Partial<Transaction>
+): Transaction => ({ ...t, ...patch });
+
+/**
+ * Prepare transaction before checking status
+ *
+ * @param {Account} a
+ * @param {Transaction} t
+ */
+export const prepareTransaction = async (
+  a: Account,
+  t: Transaction
+): Promise<Transaction> => {
+  let transaction;
+  try {
+    transaction = await buildTransaction(a, t);
+  } catch (error) {
+    return { ...t, fees: new BigNumber(0), amount: new BigNumber(0) };
+  }
+
+  const transactionFees = transaction.getFee();
+  const transactionAmount = t.subAccountId
+    ? t.amount
+    : transaction
+        .getOutputs()
+        .filter(
+          (o) =>
+            !(o.address instanceof TyphonAddress.BaseAddress) ||
+            !(
+              o.address.paymentCredential.type === TyphonTypes.HashType.ADDRESS
+            ) ||
+            o.address.paymentCredential.bipPath === undefined
+        )
+        .reduce((total, o) => total.plus(o.amount), new BigNumber(0));
+
+  return { ...t, fees: transactionFees, amount: transactionAmount };
+};