@ledgerhq/coin-cardano 0.1.0-next.0

package/src/deviceTransactionConfig.ts

@@ -0,0 +1,128 @@
+import BigNumber from "bignumber.js";
+import { getAccountCurrency, getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+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(getAccountCurrency(account).units[0], 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(
+          getAccountCurrency(mainAccount).units[0],
+          requiredMinAdaForTokens,
+          {
+            showCode: true,
+            disableRounding: true,
+          },
+        ),
+      });
+      fields.push({
+        type: "text",
+        label: "Token Name",
+        value: decodeTokenName(assetName),
+      });
+      fields.push({
+        type: "text",
+        label: "Amount",
+        value: formatCurrencyUnit(getAccountCurrency(account).units[0], transactionAmount, {
+          showCode: true,
+          disableRounding: true,
+        }),
+      });
+    } else if (account.type === "Account") {
+      fields.push({
+        type: "text",
+        label: "Amount",
+        value: formatCurrencyUnit(getAccountCurrency(account).units[0], 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/errors.ts

@@ -0,0 +1,18 @@
+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/estimateMaxSpendable.ts

@@ -0,0 +1,61 @@
+import {
+  address as TyphonAddress,
+  types as TyphonTypes,
+  Transaction as TyphonTransaction,
+} from "@stricahq/typhonjs";
+import { log } from "@ledgerhq/logs";
+import { BigNumber } from "bignumber.js";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import type { CardanoAccount, Transaction } from "./types";
+import { createTransaction } from "./createTransaction";
+import { buildTransaction } from "./buildTransaction";
+
+/**
+ * Returns the maximum possible amount for transaction
+ *
+ * @param {Object} param - the account, parentAccount and transaction
+ */
+export const estimateMaxSpendable: AccountBridge<
+  Transaction,
+  CardanoAccount
+>["estimateMaxSpendable"] = async ({ account, parentAccount, transaction }) => {
+  const mainAccount = getMainAccount(account, parentAccount);
+
+  if (mainAccount.cardanoResources.utxos.length === 0) {
+    return new BigNumber(0);
+  }
+
+  if (account.type === "TokenAccount") {
+    return account.balance;
+  }
+
+  const dummyRecipient =
+    "addr1qyqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqv2t5am";
+  const t: Transaction = {
+    ...createTransaction(account),
+    ...transaction,
+    recipient: dummyRecipient,
+    // amount field will not be used to build a transaction when useAllAmount is true
+    amount: new BigNumber(0),
+    useAllAmount: true,
+  };
+  let typhonTransaction: TyphonTransaction;
+  try {
+    typhonTransaction = await buildTransaction(mainAccount, t);
+  } catch (error) {
+    log("cardano-error", "Failed to estimate max spendable: " + String(error));
+    return new BigNumber(0);
+  }
+  const transactionAmount = typhonTransaction
+    .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 transactionAmount;
+};

package/src/getTransactionStatus.ts

@@ -0,0 +1,251 @@
+import {
+  AccountAwaitingSendPendingOperations,
+  RecipientRequired,
+  FeeNotLoaded,
+  InvalidAddress,
+  AmountRequired,
+  NotEnoughBalance,
+} from "@ledgerhq/errors";
+import { BigNumber } from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { utils as TyphonUtils } from "@stricahq/typhonjs";
+import { decodeTokenAssetId, decodeTokenCurrencyId } from "./buildSubAccounts";
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import { buildTransaction } from "./buildTransaction";
+import { isHexString, isValidAddress } from "./logic";
+import { getNetworkParameters } from "./networks";
+import {
+  CardanoInvalidPoolId,
+  CardanoStakeKeyDepositError,
+  CardanoMinAmountError,
+  CardanoNotEnoughFunds,
+} from "./errors";
+import type {
+  CardanoAccount,
+  CardanoResources,
+  Token,
+  Transaction,
+  TransactionStatus,
+} from "./types";
+
+export const getTransactionStatus: AccountBridge<
+  Transaction,
+  CardanoAccount,
+  TransactionStatus
+>["getTransactionStatus"] = async (account, transaction) => {
+  if (account.pendingOperations.length > 0) {
+    throw new AccountAwaitingSendPendingOperations();
+  }
+
+  if (account.cardanoResources.utxos.length === 0) {
+    const errors = {
+      amount: new CardanoNotEnoughFunds(),
+    };
+    return Promise.resolve({
+      errors,
+      warnings: {},
+      estimatedFees: new BigNumber(0),
+      amount: new BigNumber(transaction.amount),
+      totalSpent: new BigNumber(transaction.amount),
+    });
+  }
+
+  if (transaction.mode === "send") {
+    return getSendTransactionStatus(account, transaction);
+  } else if (transaction.mode === "delegate") {
+    return getDelegateTransactionStatus(account, transaction);
+  } else if (transaction.mode === "undelegate") {
+    return getUndelegateTransactionStatus(account, transaction);
+  } else {
+    throw new Error("Invalid transaction mode");
+  }
+};
+
+async function getSendTransactionStatus(
+  account: CardanoAccount,
+  transaction: Transaction,
+): Promise<TransactionStatus> {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+  const useAllAmount = !!transaction.useAllAmount;
+
+  const cardanoResources = account.cardanoResources;
+  const networkParams = getNetworkParameters(account.currency.id);
+
+  const estimatedFees = transaction.fees || new BigNumber(0);
+  let amount = transaction.amount;
+  let totalSpent = estimatedFees;
+
+  const tokenAccount =
+    transaction.subAccountId && account.subAccounts
+      ? account.subAccounts.find(a => {
+          return a.id === transaction.subAccountId;
+        })
+      : undefined;
+
+  let tokensToSend: Array<Token> = [];
+  if (transaction.subAccountId) {
+    // Token transaction
+    if (!tokenAccount || tokenAccount.type !== "TokenAccount") {
+      throw new Error("TokenAccount not found");
+    }
+    const { assetId } = decodeTokenCurrencyId(tokenAccount.token.id);
+    const { policyId, assetName } = decodeTokenAssetId(assetId);
+    amount = transaction.useAllAmount ? tokenAccount.balance : transaction.amount;
+    totalSpent = amount;
+    tokensToSend = [
+      {
+        policyId,
+        assetName,
+        amount,
+      },
+    ];
+  } else {
+    // ADA transaction
+    amount = transaction.useAllAmount
+      ? await estimateMaxSpendable({ account: account, transaction: transaction })
+      : amount;
+    totalSpent = amount.plus(estimatedFees);
+  }
+
+  const minTransactionAmount = TyphonUtils.calculateMinUtxoAmount(
+    tokensToSend,
+    new BigNumber(cardanoResources.protocolParams.lovelacePerUtxoWord),
+    false,
+  );
+
+  if (!transaction.fees) {
+    errors.fees = new FeeNotLoaded();
+  }
+
+  if (!transaction.recipient) {
+    errors.recipient = new RecipientRequired();
+  } else if (!isValidAddress(transaction.recipient, networkParams.networkId)) {
+    errors.recipient = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  }
+
+  if (!amount.gt(0)) {
+    errors.amount = useAllAmount ? new CardanoNotEnoughFunds() : new AmountRequired();
+  } else if (!transaction.subAccountId && amount.lt(minTransactionAmount)) {
+    errors.amount = new CardanoMinAmountError("", {
+      amount: minTransactionAmount.div(1e6).toString(),
+    });
+  } else if (tokenAccount ? totalSpent.gt(tokenAccount.balance) : totalSpent.gt(account.balance)) {
+    errors.amount = new NotEnoughBalance();
+  } else {
+    try {
+      await buildTransaction(account, transaction);
+    } catch (e: any) {
+      if (
+        e.message.toLowerCase() === "not enough ada" ||
+        e.message.toLowerCase() === "not enough tokens"
+      ) {
+        errors.amount = new CardanoNotEnoughFunds();
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  return Promise.resolve({
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  });
+}
+
+async function getDelegateTransactionStatus(
+  account: CardanoAccount,
+  transaction: Transaction,
+): Promise<TransactionStatus> {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+
+  if (!transaction.fees) {
+    errors.fees = new FeeNotLoaded();
+  }
+
+  const estimatedFees = transaction.fees || new BigNumber(0);
+
+  if (!transaction.poolId || !isHexString(transaction.poolId) || transaction.poolId.length !== 56) {
+    errors.poolId = new CardanoInvalidPoolId();
+  } else {
+    try {
+      await buildTransaction(account, transaction);
+    } catch (e: any) {
+      if (
+        e.message.toLowerCase() === "not enough ada" ||
+        e.message.toLowerCase() === "not enough tokens"
+      ) {
+        errors.amount = new CardanoNotEnoughFunds();
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  const stakeKeyRegisterDeposit = new BigNumber(
+    account.cardanoResources.protocolParams.stakeKeyDeposit,
+  );
+  if (
+    !account.cardanoResources.delegation?.status &&
+    account.spendableBalance.isLessThan(stakeKeyRegisterDeposit)
+  ) {
+    errors.amount = new CardanoStakeKeyDepositError("", {
+      depositAmount: stakeKeyRegisterDeposit.div(1e6).toString(),
+    });
+  }
+
+  return Promise.resolve({
+    errors,
+    warnings,
+    estimatedFees,
+    amount: new BigNumber(0),
+    totalSpent: estimatedFees,
+  });
+}
+
+async function getUndelegateTransactionStatus(
+  account: CardanoAccount,
+  transaction: Transaction,
+): Promise<TransactionStatus> {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+
+  const cardanoResources = account.cardanoResources as CardanoResources;
+
+  const estimatedFees = transaction.fees || new BigNumber(0);
+
+  if (!cardanoResources.delegation?.status) {
+    throw new Error("StakeKey is not registered");
+  }
+
+  if (account.balance.eq(0)) {
+    throw new CardanoNotEnoughFunds();
+  }
+
+  try {
+    await buildTransaction(account, transaction);
+  } catch (e: any) {
+    if (
+      e.message.toLowerCase() === "not enough ada" ||
+      e.message.toLowerCase() === "not enough tokens"
+    ) {
+      errors.amount = new CardanoNotEnoughFunds();
+    } else {
+      throw e;
+    }
+  }
+
+  return Promise.resolve({
+    errors,
+    warnings,
+    estimatedFees,
+    amount: new BigNumber(0),
+    totalSpent: estimatedFees,
+  });
+}

package/src/getTransactionStatus.unit.test.ts

@@ -0,0 +1,45 @@
+import BigNumber from "bignumber.js";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { CardanoAccount, Transaction } from "./types";
+
+describe("getTransactionStatus", () => {
+  it("should return not enough funds error when there are no utxos", async () => {
+    const initialAccount = {
+      pendingOperations: [],
+      cardanoResources: {
+        utxos: [],
+      },
+    } as unknown as CardanoAccount;
+
+    const sendTx: Transaction = {
+      amount: new BigNumber(1000000),
+      recipient:
+        "addr1qxqm3nxwzf70ke9jqa2zrtrevjznpv6yykptxnv34perjc8a7zgxmpv5pgk4hhhe0m9kfnlsf5pt7d2ahkxaul2zygrq3nura9",
+      mode: "send",
+      family: "cardano",
+      poolId: undefined,
+    };
+    const sendTxRes = await getTransactionStatus(initialAccount, sendTx);
+    expect(sendTxRes.errors.amount.name).toBe("CardanoNotEnoughFunds");
+
+    const delegateTx: Transaction = {
+      amount: new BigNumber(0),
+      recipient: "",
+      mode: "delegate",
+      family: "cardano",
+      poolId: "d0f48f07e4e5eb8040a988085f7ea3bd32d71a2e2998d53e9bbc959a",
+    };
+    const delegateTxRes = await getTransactionStatus(initialAccount, delegateTx);
+    expect(delegateTxRes.errors.amount.name).toBe("CardanoNotEnoughFunds");
+
+    const undelegateTx: Transaction = {
+      amount: new BigNumber(0),
+      recipient: "",
+      mode: "undelegate",
+      family: "cardano",
+      poolId: undefined,
+    };
+    const undelegateTxRes = await getTransactionStatus(initialAccount, undelegateTx);
+    expect(undelegateTxRes.errors.amount.name).toBe("CardanoNotEnoughFunds");
+  });
+});

package/src/hw-getAddress.ts

@@ -0,0 +1,37 @@
+import { utils as TyphonUtils } from "@stricahq/typhonjs";
+import { address as TyphonAddress } from "@stricahq/typhonjs";
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { getBipPathFromString, getBipPathString } from "./logic";
+import { StakeChain } from "./types";
+import { STAKING_ADDRESS_INDEX } from "./constants";
+import { getNetworkParameters } from "./networks";
+import { CardanoSigner } from "./signer";
+
+const resolver = (signerContext: SignerContext<CardanoSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify, currency }: GetAddressOptions) => {
+    const spendingPath = getBipPathFromString(path);
+    const stakingPathString = getBipPathString({
+      account: spendingPath.account,
+      chain: StakeChain.stake,
+      index: STAKING_ADDRESS_INDEX,
+    });
+    const networkParams = getNetworkParameters(currency.id);
+
+    const r = await signerContext(deviceId, signer =>
+      signer.getAddress({ path, stakingPathString, networkParams, verify }),
+    );
+
+    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;