@ledgerhq/coin-cardano 0.1.0-next.0

package/src/buildTransaction.ts

@@ -0,0 +1,435 @@
+import {
+  Transaction as TyphonTransaction,
+  types as TyphonTypes,
+  utils as TyphonUtils,
+} from "@stricahq/typhonjs";
+import BigNumber from "bignumber.js";
+import type { TokenAccount } from "@ledgerhq/types-live";
+import { RewardAddress } from "@stricahq/typhonjs/dist/address";
+import { getAccountStakeCredential, getBaseAddress, getTTL, mergeTokens, isTestnet } from "./logic";
+import { decodeTokenAssetId, decodeTokenCurrencyId, getTokenAssetId } from "./buildSubAccounts";
+import { getNetworkParameters } from "./networks";
+import {
+  CardanoAccount,
+  CardanoOutput,
+  CardanoResources,
+  PaymentCredential,
+  Token,
+  Transaction,
+} from "./types";
+
+function getTyphonInputFromUtxo(utxo: CardanoOutput): TyphonTypes.Input {
+  const address = TyphonUtils.getAddressFromHex(utxo.address) as TyphonTypes.ShelleyAddress;
+  if (address.paymentCredential.type === TyphonTypes.HashType.ADDRESS) {
+    address.paymentCredential.bipPath = utxo.paymentCredential.path;
+  }
+
+  return {
+    txId: utxo.hash,
+    index: utxo.index,
+    amount: new BigNumber(utxo.amount),
+    tokens: utxo.tokens,
+    address: address,
+  };
+}
+
+function getRewardWithdrawalCertificate(account: CardanoAccount): TyphonTypes.Withdrawal | null {
+  if (!account.cardanoResources.delegation?.rewards.gt(0)) {
+    return null;
+  }
+
+  const stakeCredential = getAccountStakeCredential(account.xpub as string, account.index);
+  const stakeKeyHashCredential: TyphonTypes.HashCredential = {
+    hash: stakeCredential.key,
+    type: TyphonTypes.HashType.ADDRESS,
+    bipPath: stakeCredential.path,
+  };
+
+  const networkId = isTestnet(account.currency)
+    ? TyphonTypes.NetworkId.TESTNET
+    : TyphonTypes.NetworkId.MAINNET;
+  const rewardAddress = new RewardAddress(networkId, stakeKeyHashCredential);
+  const rewardsWithdrawalCertificate: TyphonTypes.Withdrawal = {
+    rewardAccount: rewardAddress,
+    amount: account.cardanoResources.delegation.rewards,
+  };
+
+  return rewardsWithdrawalCertificate;
+}
+
+const buildSendTokenTransaction = async ({
+  account,
+  transaction,
+  tokenAccount,
+  typhonTx,
+  receiverAddress,
+  changeAddress,
+}: {
+  account: CardanoAccount;
+  transaction: Transaction;
+  tokenAccount: TokenAccount;
+  typhonTx: TyphonTransaction;
+  receiverAddress: TyphonTypes.CardanoAddress;
+  changeAddress: TyphonTypes.CardanoAddress;
+}): Promise<TyphonTransaction> => {
+  const cardanoResources = account.cardanoResources as CardanoResources;
+
+  const { assetId } = decodeTokenCurrencyId(tokenAccount.token.id);
+  const { policyId, assetName } = decodeTokenAssetId(assetId);
+  const transactionAmount = transaction.useAllAmount ? tokenAccount.balance : transaction.amount;
+
+  const tokensToSend = [
+    {
+      policyId,
+      assetName,
+      amount: transactionAmount,
+    },
+  ];
+  const tokenUtxos: Array<CardanoOutput> = [];
+  const otherUtxos: Array<CardanoOutput> = [];
+
+  cardanoResources.utxos.forEach(u => {
+    if (u.tokens.some(t => getTokenAssetId(t) === assetId)) {
+      tokenUtxos.push(u);
+    } else {
+      otherUtxos.push(u);
+    }
+  });
+  const sortedTokenUtxo = tokenUtxos.sort((a, b) => {
+    const sendingTokenA = a.tokens.find(t => getTokenAssetId(t) === assetId) as Token;
+    const sendingTokenB = b.tokens.find(t => getTokenAssetId(t) === assetId) as Token;
+    const diff = sendingTokenB.amount.minus(sendingTokenA.amount);
+    return diff.eq(0) ? 0 : diff.lt(0) ? -1 : 1;
+  });
+  const sortedOtherUtxos = otherUtxos.sort((a, b) => {
+    const diff = b.amount.minus(a.amount);
+    return diff.eq(0) ? 0 : diff.lt(0) ? -1 : 1;
+  });
+
+  const totalAddedTokenAmount = new BigNumber(0);
+  const requiredMinAdaForTokens = TyphonUtils.calculateMinUtxoAmount(
+    tokensToSend,
+    new BigNumber(cardanoResources.protocolParams.lovelacePerUtxoWord),
+  );
+  // Add enough utxo to cover token amount
+  for (let i = 0; i < sortedTokenUtxo.length; i++) {
+    const u = sortedTokenUtxo[i];
+    const sendingToken = u.tokens.find(t => getTokenAssetId(t) === assetId) as Token;
+    typhonTx.addInput(getTyphonInputFromUtxo(u));
+    totalAddedTokenAmount.plus(sendingToken.amount);
+    if (totalAddedTokenAmount.gte(transactionAmount)) break;
+  }
+
+  const requiredInputAmount = requiredMinAdaForTokens.plus(10e6);
+  // Add enough utxos to cover the transaction fees
+  for (let i = 0; i < sortedOtherUtxos.length; i++) {
+    const u = sortedOtherUtxos[i];
+    if (typhonTx.getInputAmount().ada.gte(requiredInputAmount)) {
+      break;
+    }
+    typhonTx.addInput(getTyphonInputFromUtxo(u));
+  }
+
+  const rewardsWithdrawalCertificate = getRewardWithdrawalCertificate(account);
+  if (rewardsWithdrawalCertificate) typhonTx.addWithdrawal(rewardsWithdrawalCertificate);
+
+  typhonTx.addOutput({
+    address: receiverAddress,
+    amount: requiredMinAdaForTokens,
+    tokens: tokensToSend,
+  });
+
+  return typhonTx.prepareTransaction({
+    inputs: [],
+    changeAddress,
+  });
+};
+
+const buildSendAdaTransaction = async ({
+  account,
+  transaction,
+  typhonTx,
+  receiverAddress,
+  changeAddress,
+}: {
+  account: CardanoAccount;
+  transaction: Transaction;
+  typhonTx: TyphonTransaction;
+  receiverAddress: TyphonTypes.CardanoAddress;
+  changeAddress: TyphonTypes.CardanoAddress;
+}): Promise<TyphonTransaction> => {
+  const cardanoResources = account.cardanoResources as CardanoResources;
+  const protocolParams = cardanoResources.protocolParams;
+
+  if (transaction.useAllAmount) {
+    // add all utxo as input
+    cardanoResources.utxos.forEach(u => typhonTx.addInput(getTyphonInputFromUtxo(u)));
+
+    const tokenBalance = mergeTokens(cardanoResources.utxos.map(u => u.tokens).flat());
+
+    // if account holds any tokens then add it to changeAddress,
+    // with minimum required ADA to spend those tokens
+    if (tokenBalance.length) {
+      const minAmountToSpendTokens = TyphonUtils.calculateMinUtxoAmount(
+        tokenBalance,
+        new BigNumber(protocolParams.lovelacePerUtxoWord),
+        false,
+      );
+      typhonTx.addOutput({
+        address: changeAddress,
+        amount: minAmountToSpendTokens,
+        tokens: tokenBalance,
+      });
+    }
+
+    const rewardsWithdrawalCertificate = getRewardWithdrawalCertificate(account);
+    if (rewardsWithdrawalCertificate) typhonTx.addWithdrawal(rewardsWithdrawalCertificate);
+
+    return typhonTx.prepareTransaction({
+      inputs: [],
+      changeAddress: receiverAddress,
+    });
+  }
+
+  // sorting utxo from higher to lower ADA value
+  // to minimize the number of utxo use in transaction
+  const sortedUtxos = cardanoResources.utxos.sort((a, b) => {
+    const diff = b.amount.minus(a.amount);
+    return diff.eq(0) ? 0 : diff.lt(0) ? -1 : 1;
+  });
+
+  const transactionInputs: Array<TyphonTypes.Input> = [];
+  const usedUtxoAdaAmount = new BigNumber(0);
+  // Add 10 ADA as buffer for utxo selection to cover the transaction fees.
+  const requiredInputAmount = transaction.amount.plus(10e6);
+  for (let i = 0; i < sortedUtxos.length && usedUtxoAdaAmount.lte(requiredInputAmount); i++) {
+    const utxo = sortedUtxos[i];
+    const transactionInput = getTyphonInputFromUtxo(utxo);
+    transactionInputs.push(transactionInput);
+    usedUtxoAdaAmount.plus(transactionInput.amount);
+  }
+
+  const rewardsWithdrawalCertificate = getRewardWithdrawalCertificate(account);
+  if (rewardsWithdrawalCertificate) typhonTx.addWithdrawal(rewardsWithdrawalCertificate);
+
+  typhonTx.addOutput({
+    address: receiverAddress,
+    amount: transaction.amount,
+    tokens: [],
+  });
+
+  return typhonTx.prepareTransaction({
+    inputs: transactionInputs,
+    changeAddress,
+  });
+};
+
+const buildDelegateTransaction = async ({
+  account,
+  transaction,
+  typhonTx,
+  changeAddress,
+}: {
+  account: CardanoAccount;
+  transaction: Transaction;
+  typhonTx: TyphonTransaction;
+  changeAddress: TyphonTypes.CardanoAddress;
+}): Promise<TyphonTransaction> => {
+  const cardanoResources = account.cardanoResources as CardanoResources;
+
+  const stakeCredential = getAccountStakeCredential(account.xpub as string, account.index);
+  const stakeKeyHashCredential: TyphonTypes.HashCredential = {
+    hash: stakeCredential.key,
+    type: TyphonTypes.HashType.ADDRESS,
+    bipPath: stakeCredential.path,
+  };
+
+  if (!cardanoResources.delegation || !cardanoResources.delegation.status) {
+    const stakeRegistrationCert: TyphonTypes.StakeRegistrationCertificate = {
+      certType: TyphonTypes.CertificateType.STAKE_REGISTRATION,
+      stakeCredential: stakeKeyHashCredential,
+    };
+    typhonTx.addCertificate(stakeRegistrationCert);
+  }
+
+  const delegationCert: TyphonTypes.StakeDelegationCertificate = {
+    certType: TyphonTypes.CertificateType.STAKE_DELEGATION,
+    stakeCredential: stakeKeyHashCredential,
+    poolHash: transaction.poolId as string,
+  };
+  typhonTx.addCertificate(delegationCert);
+
+  // sorting utxo from higher to lower ADA value
+  // to minimize the number of utxo use in transaction
+  const sortedUtxos = cardanoResources.utxos.sort((a, b) => {
+    const diff = b.amount.minus(a.amount);
+    return diff.eq(0) ? 0 : diff.lt(0) ? -1 : 1;
+  });
+
+  const transactionInputs: Array<TyphonTypes.Input> = [];
+  const usedUtxoAdaAmount = new BigNumber(0);
+  // Add 10 ADA as buffer for utxo selection to cover the transaction fees.
+  const requiredInputAmount = transaction.amount.plus(10e6);
+  for (let i = 0; i < sortedUtxos.length && usedUtxoAdaAmount.lte(requiredInputAmount); i++) {
+    const utxo = sortedUtxos[i];
+    const transactionInput = getTyphonInputFromUtxo(utxo);
+    transactionInputs.push(transactionInput);
+    usedUtxoAdaAmount.plus(transactionInput.amount);
+  }
+
+  const rewardsWithdrawalCertificate = getRewardWithdrawalCertificate(account);
+  if (rewardsWithdrawalCertificate) typhonTx.addWithdrawal(rewardsWithdrawalCertificate);
+
+  return typhonTx.prepareTransaction({
+    inputs: transactionInputs,
+    changeAddress,
+  });
+};
+
+const buildUndelegateTransaction = async ({
+  account,
+  transaction,
+  typhonTx,
+  changeAddress,
+}: {
+  account: CardanoAccount;
+  transaction: Transaction;
+  typhonTx: TyphonTransaction;
+  changeAddress: TyphonTypes.CardanoAddress;
+}): Promise<TyphonTransaction> => {
+  const cardanoResources = account.cardanoResources as CardanoResources;
+
+  const stakeCredential = getAccountStakeCredential(account.xpub as string, account.index);
+  const stakeKeyHashCredential: TyphonTypes.HashCredential = {
+    hash: stakeCredential.key,
+    type: TyphonTypes.HashType.ADDRESS,
+    bipPath: stakeCredential.path,
+  };
+
+  if (!cardanoResources.delegation || !cardanoResources.delegation.status) {
+    throw new Error("StakeKey is not registered");
+  }
+
+  const rewardsWithdrawalCertificate = getRewardWithdrawalCertificate(account);
+  if (rewardsWithdrawalCertificate) typhonTx.addWithdrawal(rewardsWithdrawalCertificate);
+
+  const stakeKeyDeRegistrationCertificate: TyphonTypes.StakeDeRegistrationCertificate = {
+    certType: TyphonTypes.CertificateType.STAKE_DE_REGISTRATION,
+    stakeCredential: stakeKeyHashCredential,
+  };
+  typhonTx.addCertificate(stakeKeyDeRegistrationCertificate);
+
+  // sorting utxo from higher to lower ADA value
+  // to minimize the number of utxo use in transaction
+  const sortedUtxos = cardanoResources.utxos.sort((a, b) => {
+    const diff = b.amount.minus(a.amount);
+    return diff.eq(0) ? 0 : diff.lt(0) ? -1 : 1;
+  });
+
+  const transactionInputs: Array<TyphonTypes.Input> = [];
+  const usedUtxoAdaAmount = new BigNumber(0);
+  // Add 10 ADA as buffer for utxo selection to cover the transaction fees.
+  const requiredInputAmount = transaction.amount.plus(10e6);
+  for (let i = 0; i < sortedUtxos.length && usedUtxoAdaAmount.lte(requiredInputAmount); i++) {
+    const utxo = sortedUtxos[i];
+    const transactionInput = getTyphonInputFromUtxo(utxo);
+    transactionInputs.push(transactionInput);
+    usedUtxoAdaAmount.plus(transactionInput.amount);
+  }
+
+  return typhonTx.prepareTransaction({
+    inputs: transactionInputs,
+    changeAddress,
+  });
+};
+
+/**
+ *
+ * @param {CardanoAccount} account
+ * @param {Transaction} transaction
+ *
+ * @returns {TyphonTransaction}
+ */
+export const buildTransaction = async (
+  account: CardanoAccount,
+  transaction: Transaction,
+): Promise<TyphonTransaction> => {
+  const cardanoResources = account.cardanoResources as CardanoResources;
+  const protocolParams = cardanoResources.protocolParams;
+
+  const typhonTx = new TyphonTransaction({
+    protocolParams: {
+      minFeeA: new BigNumber(protocolParams.minFeeA),
+      minFeeB: new BigNumber(protocolParams.minFeeB),
+      stakeKeyDeposit: new BigNumber(protocolParams.stakeKeyDeposit),
+      lovelacePerUtxoWord: new BigNumber(protocolParams.lovelacePerUtxoWord),
+      collateralPercent: new BigNumber(protocolParams.collateralPercent),
+      priceSteps: new BigNumber(protocolParams.priceSteps),
+      priceMem: new BigNumber(protocolParams.priceMem),
+      languageView: protocolParams.languageView,
+    },
+  });
+  const ttl = getTTL(account.currency.id);
+  typhonTx.setTTL(ttl);
+
+  const metadata: Array<TyphonTypes.Metadata> = [];
+  if (transaction.memo) {
+    metadata.push({
+      label: 674,
+      data: new Map([["msg", [transaction.memo]]]),
+    });
+  }
+  if (metadata.length) {
+    typhonTx.setAuxiliaryData({ metadata });
+  }
+
+  const networkParams = getNetworkParameters(account.currency.id);
+  const unusedInternalCred = cardanoResources.internalCredentials.find(
+    cred => !cred.isUsed,
+  ) as PaymentCredential;
+
+  const changeAddress = getBaseAddress({
+    networkId: networkParams.networkId,
+    paymentCred: unusedInternalCred,
+    stakeCred: getAccountStakeCredential(account.xpub as string, account.index),
+  });
+
+  if (transaction.mode === "send") {
+    const receiverAddress = TyphonUtils.getAddressFromBech32(transaction.recipient);
+    if (transaction.subAccountId) {
+      // Token Transaction
+      const tokenAccount = account.subAccounts
+        ? account.subAccounts.find(a => {
+            return a.id === transaction.subAccountId;
+          })
+        : undefined;
+
+      if (!tokenAccount || tokenAccount.type !== "TokenAccount") {
+        throw new Error("TokenAccount not found");
+      }
+
+      return buildSendTokenTransaction({
+        account,
+        transaction,
+        tokenAccount,
+        typhonTx,
+        receiverAddress,
+        changeAddress,
+      });
+    }
+    // Normal ADA Transaction
+    return buildSendAdaTransaction({
+      account,
+      transaction,
+      typhonTx,
+      receiverAddress,
+      changeAddress,
+    });
+  } else if (transaction.mode === "delegate") {
+    return buildDelegateTransaction({ account, transaction, typhonTx, changeAddress });
+  } else if (transaction.mode === "undelegate") {
+    return buildUndelegateTransaction({ account, transaction, typhonTx, changeAddress });
+  } else {
+    throw new Error("Invalid transaction mode");
+  }
+};

package/src/cli-transaction.ts

@@ -0,0 +1,82 @@
+import { Account, AccountLike, TokenAccount } from "@ledgerhq/types-live";
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+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: any) => {
+    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 function makeCliTools() {
+  return {
+    options,
+    inferAccounts,
+    inferTransactions,
+  };
+}

package/src/constants.ts

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

@@ -0,0 +1,18 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction } from "./types";
+
+/**
+ * Create an empty transaction
+ *
+ * @returns {Transaction}
+ */
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => ({
+  family: "cardano",
+  mode: "send",
+  amount: new BigNumber(0),
+  recipient: "",
+  useAllAmount: false,
+  fees: new BigNumber(0),
+  poolId: undefined,
+});

package/src/datasets/rawAccount.1.ts

@@ -0,0 +1,19 @@
+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",
+  blockHeight: 0,
+  operations: [],
+  pendingOperations: [],
+  currencyId: "cardano_testnet",
+  lastSyncDate: "",
+  balance: "10098829375",
+  xpub: "806499588e0c4a58f4119f7e6e096bf42c3f774a528d2acec9e82ceebf87d1ceb3d4f3622dd2c77c65cc89c123f79337db22cf8a69f122e36dab1bf5083bf82d",
+};

package/src/datasets/scanAccounts.ts

@@ -0,0 +1,23 @@
+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
+    `,
+  },
+];