@ledgerhq/coin-cardano 0.1.0-next.0

package/src/buildOptimisticOperation.ts

@@ -0,0 +1,181 @@
+import BigNumber from "bignumber.js";
+import { OperationType } from "@ledgerhq/types-live";
+import { HashType } from "@stricahq/typhonjs/dist/types";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import ShelleyTypeAddress from "@stricahq/typhonjs/dist/address/ShelleyTypeAddress";
+import { types as TyphonTypes, Transaction as TyphonTransaction } from "@stricahq/typhonjs";
+import { getAccountStakeCredential, getOperationType } from "./logic";
+import { MEMO_LABEL } from "./constants";
+import {
+  CardanoAccount,
+  CardanoOperation,
+  CardanoOperationExtra,
+  CardanoResources,
+  Transaction,
+} from "./types";
+
+export const buildOptimisticOperation = (
+  account: CardanoAccount,
+  unsignedTransaction: TyphonTransaction,
+  transaction: Transaction,
+): CardanoOperation => {
+  const cardanoResources = account.cardanoResources as CardanoResources;
+  const accountCreds = new Set(
+    [...cardanoResources.externalCredentials, ...cardanoResources.internalCredentials].map(
+      cred => cred.key,
+    ),
+  );
+  const stakeCredential = getAccountStakeCredential(account.xpub as string, account.index);
+  const protocolParams = account.cardanoResources.protocolParams;
+
+  const accountInput = unsignedTransaction
+    .getInputs()
+    .reduce(
+      (total, i) =>
+        accountCreds.has(i.address.paymentCredential.hash) ? total.plus(i.amount) : total.plus(0),
+      new BigNumber(0),
+    );
+
+  const accountOutput = unsignedTransaction
+    .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 txCertificates = unsignedTransaction.getCertificates();
+  const stakeRegistrationCertificates = txCertificates.filter(
+    c => c.certType === TyphonTypes.CertificateType.STAKE_REGISTRATION,
+  );
+  const stakeDeRegistrationCertificates = txCertificates.filter(
+    c => c.certType === TyphonTypes.CertificateType.STAKE_DE_REGISTRATION,
+  );
+  const txWithdrawals = unsignedTransaction.getWithdrawals();
+
+  const transactionHash = unsignedTransaction.getTransactionHash().toString("hex");
+  const auxiliaryData = unsignedTransaction.getAuxiliaryData();
+  const extra: CardanoOperationExtra = {};
+  if (auxiliaryData) {
+    const memoMetadata = auxiliaryData.metadata.find(m => m.label === MEMO_LABEL);
+    if (memoMetadata && memoMetadata.data instanceof Map) {
+      const msg = memoMetadata.data.get("msg");
+      if (Array.isArray(msg) && msg.length) {
+        extra.memo = msg.join(", ");
+      }
+    }
+  }
+
+  let operationValue = accountOutput.minus(accountInput);
+
+  if (stakeRegistrationCertificates.length) {
+    const walletRegistration = stakeRegistrationCertificates.find(
+      c =>
+        c.stakeCredential.type === HashType.ADDRESS &&
+        c.stakeCredential.hash === stakeCredential.key,
+    );
+    if (walletRegistration) {
+      extra.deposit = formatCurrencyUnit(
+        account.currency.units[0],
+        new BigNumber(protocolParams.stakeKeyDeposit),
+        {
+          showCode: true,
+          disableRounding: true,
+        },
+      );
+    }
+  }
+
+  if (stakeDeRegistrationCertificates.length) {
+    const walletDeRegistration = stakeDeRegistrationCertificates.find(
+      c =>
+        c.stakeCredential.type === HashType.ADDRESS &&
+        c.stakeCredential.hash === stakeCredential.key,
+    );
+    if (walletDeRegistration) {
+      operationValue = operationValue.minus(protocolParams.stakeKeyDeposit);
+      extra.refund = formatCurrencyUnit(
+        account.currency.units[0],
+        new BigNumber(protocolParams.stakeKeyDeposit),
+        {
+          showCode: true,
+          disableRounding: true,
+        },
+      );
+    }
+  }
+
+  if (txWithdrawals && txWithdrawals.length) {
+    const walletWithdraw = txWithdrawals.find(
+      w =>
+        w.rewardAccount.stakeCredential.type === HashType.ADDRESS &&
+        w.rewardAccount.stakeCredential.hash === stakeCredential.key,
+    );
+    if (walletWithdraw) {
+      operationValue = operationValue.minus(walletWithdraw.amount);
+      extra.rewards = formatCurrencyUnit(
+        account.currency.units[0],
+        new BigNumber(walletWithdraw.amount),
+        {
+          showCode: true,
+          disableRounding: true,
+        },
+      );
+    }
+  }
+
+  const opType: OperationType = txCertificates.find(
+    c => c.certType === TyphonTypes.CertificateType.STAKE_DELEGATION,
+  )
+    ? "DELEGATE"
+    : txCertificates.find(c => c.certType === TyphonTypes.CertificateType.STAKE_DE_REGISTRATION)
+      ? "UNDELEGATE"
+      : getOperationType({
+          valueChange: operationValue,
+          fees: unsignedTransaction.getFee(),
+        });
+
+  const op: CardanoOperation = {
+    id: encodeOperationId(account.id, transactionHash, opType),
+    hash: transactionHash,
+    type: opType,
+    value: operationValue.absoluteValue(),
+    fee: unsignedTransaction.getFee(),
+    blockHash: undefined,
+    blockHeight: null,
+    senders: unsignedTransaction.getInputs().map(i => i.address.getBech32()),
+    recipients: unsignedTransaction.getOutputs().map(o => o.address.getBech32()),
+    accountId: account.id,
+    date: new Date(),
+    extra,
+  };
+
+  const tokenAccount = transaction.subAccountId
+    ? account.subAccounts?.find(ta => ta.id === transaction.subAccountId)
+    : null;
+
+  if (tokenAccount && opType === "OUT") {
+    op.subOperations = [
+      {
+        id: encodeOperationId(tokenAccount.id, transactionHash, opType),
+        hash: transactionHash,
+        type: opType,
+        value: transaction.useAllAmount ? tokenAccount.balance : transaction.amount,
+        fee: transaction.fees as BigNumber,
+        blockHash: undefined,
+        blockHeight: null,
+        senders: unsignedTransaction.getInputs().map(i => i.address.getBech32()),
+        recipients: unsignedTransaction.getOutputs().map(o => o.address.getBech32()),
+        accountId: tokenAccount.id,
+        date: new Date(),
+        extra: {},
+      },
+    ];
+  }
+
+  return op;
+};

package/src/buildSubAccounts.ts

@@ -0,0 +1,170 @@
+import {
+  decodeTokenAccountId,
+  emptyHistoryCache,
+  encodeTokenAccountId,
+} from "@ledgerhq/coin-framework/account/index";
+import keyBy from "lodash/keyBy";
+import groupBy from "lodash/groupBy";
+import BigNumber from "bignumber.js";
+import { findTokenById } from "@ledgerhq/cryptoassets";
+import { utils as TyphonUtils } from "@stricahq/typhonjs";
+import type { Account, TokenAccount } from "@ledgerhq/types-live";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { CardanoOperation, CardanoOperationExtra, PaymentCredential, Token } from "./types";
+import { getAccountChange, getMemoFromTx, isHexString } from "./logic";
+import { APITransaction } from "./api/api-types";
+
+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: [],
+        balanceHistoryCache: emptyHistoryCache,
+        swapHistory: [],
+      };
+      tokenAccountsById[tokenAccountId] = tokenAccount;
+    }
+  }
+  return Object.values(tokenAccountsById);
+}