@ledgerhq/coin-cardano 0.1.0-next.0

package/src/types.ts

@@ -0,0 +1,227 @@
+import type { BigNumber } from "bignumber.js";
+import { types as TyphonTypes } from "@stricahq/typhonjs";
+import type {
+  Account,
+  AccountRaw,
+  Operation,
+  OperationRaw,
+  TransactionCommon,
+  TransactionCommonRaw,
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+
+export enum PaymentChain {
+  external = 0,
+  internal = 1,
+}
+
+export enum StakeChain {
+  stake = 2,
+}
+
+export enum NetworkId {
+  testnet = 0,
+  mainnet = 1,
+}
+
+export type BipPath = {
+  purpose: number;
+  coin: number;
+  account: number;
+  chain: PaymentChain | StakeChain;
+  index: number;
+};
+
+export type BipPathRaw = {
+  purpose: number;
+  coin: number;
+  account: number;
+  chain: PaymentChain | StakeChain;
+  index: number;
+};
+
+export type Token = {
+  assetName: string;
+  policyId: string;
+  amount: BigNumber;
+};
+
+export type TokenRaw = {
+  assetName: string;
+  policyId: string;
+  amount: string;
+};
+
+export type PaymentKeyPath = {
+  key: string;
+  path: BipPath;
+};
+
+export type PaymentCredential = {
+  isUsed: boolean;
+  key: string;
+  path: BipPath;
+};
+
+export type PaymentCredentialRaw = {
+  isUsed: boolean;
+  key: string;
+  path: BipPathRaw;
+};
+
+export type StakeCredential = {
+  key: string;
+  path: BipPath;
+};
+
+export type CardanoOutput = {
+  hash: string;
+  index: number;
+  address: string;
+  amount: BigNumber;
+  tokens: Array<Token>;
+  paymentCredential: {
+    key: string;
+    path: BipPath;
+  };
+};
+
+export type CardanoOutputRaw = {
+  hash: string;
+  index: number;
+  address: string;
+  amount: string;
+  tokens: Array<TokenRaw>;
+  paymentCredential: {
+    key: string;
+    path: BipPath;
+  };
+};
+
+export type ProtocolParams = {
+  minFeeA: string;
+  minFeeB: string;
+  stakeKeyDeposit: string;
+  lovelacePerUtxoWord: string;
+  collateralPercent: string;
+  priceSteps: string;
+  priceMem: string;
+  languageView: TyphonTypes.LanguageView;
+};
+
+export type ProtocolParamsRaw = {
+  minFeeA: string;
+  minFeeB: string;
+  stakeKeyDeposit: string;
+  lovelacePerUtxoWord: string;
+  collateralPercent: string;
+  priceSteps: string;
+  priceMem: string;
+  // TyphonTypes.LanguageView is already a raw type
+  languageView: TyphonTypes.LanguageView;
+};
+
+export type CardanoDelegation = {
+  status: boolean;
+  poolId: string;
+  ticker: string;
+  name: string;
+  rewards: BigNumber;
+};
+
+export type CardanoDelegationRaw = {
+  status: boolean;
+  poolId: string;
+  ticker: string;
+  name: string;
+  rewards: string;
+};
+
+/**
+ * Cardano account resources
+ */
+export type CardanoResources = {
+  externalCredentials: Array<PaymentCredential>;
+  internalCredentials: Array<PaymentCredential>;
+  delegation: CardanoDelegation | undefined;
+  utxos: Array<CardanoOutput>;
+  protocolParams: ProtocolParams;
+};
+
+/**
+ * Cardano account resources from raw JSON
+ */
+export type CardanoResourcesRaw = {
+  externalCredentials: Array<PaymentCredentialRaw>;
+  internalCredentials: Array<PaymentCredentialRaw>;
+  delegation: CardanoDelegationRaw | undefined;
+  utxos: Array<CardanoOutputRaw>;
+  protocolParams: ProtocolParamsRaw;
+};
+
+export type CardanoOperationMode = "send" | "delegate" | "undelegate";
+
+/**
+ * Cardano transaction
+ */
+export type Transaction = TransactionCommon & {
+  mode: CardanoOperationMode;
+  family: "cardano";
+  fees?: BigNumber;
+  memo?: string;
+  poolId: string | undefined;
+  // add here all transaction-specific fields if you implement other modes than "send"
+};
+
+/**
+ * Cardano transaction from a raw JSON
+ */
+export type TransactionRaw = TransactionCommonRaw & {
+  family: "cardano";
+  mode: CardanoOperationMode;
+  fees?: string;
+  memo?: string;
+  poolId: string | undefined;
+  // also the transaction fields as raw JSON data
+};
+
+export type CardanoLikeNetworkParameters = {
+  identifier: string;
+  networkId: number;
+  chainStartTime: number;
+  byronSlotDuration: number;
+  byronSlotsPerEpoch: number;
+  shelleyStartEpoch: number;
+  shelleySlotDuration: number;
+  shelleySlotsPerEpoch: number;
+  addressPrefix: string;
+  poolIdPrefix: string;
+};
+
+/**
+ * Cardano currency data that will be preloaded.
+ */
+export type CardanoPreloadData = {
+  protocolParams: ProtocolParams;
+};
+
+export type CardanoAccount = Account & { cardanoResources: CardanoResources };
+
+export type CardanoAccountRaw = AccountRaw & {
+  cardanoResources: CardanoResourcesRaw;
+};
+
+export type TransactionStatus = TransactionStatusCommon;
+
+export type TransactionStatusRaw = TransactionStatusCommonRaw;
+
+export type CardanoOperation = Operation<CardanoOperationExtra>;
+export type CardanoOperationRaw = OperationRaw<CardanoOperationExtra>;
+
+export type CardanoOperationExtra = {
+  memo?: string;
+  deposit?: string;
+  refund?: string;
+  rewards?: string;
+};

package/src/typhonSerializer.ts

@@ -0,0 +1,259 @@
+import {
+  types as TyphonTypes,
+  address as TyphonAddress,
+  Transaction as TyphonTransaction,
+} from "@stricahq/typhonjs";
+import groupBy from "lodash/groupBy";
+import { getBipPathString } from "./logic";
+import { CertificateType } from "@stricahq/typhonjs/dist/types";
+import { SignerTxCertificate, SignerTxInput, SignerTxOutput, SignerTxWithdrawal } from "./signer";
+
+/**
+ * Convert StricaTypes Transaction into a simpler types.
+ * We are keeping the minimal necessary for a signer.
+ */
+export default function (transaction: TyphonTransaction, accountIndex: number) {
+  const ledgerAppInputs = transaction.getInputs().map(prepareLedgerInput(accountIndex));
+  const ledgerAppOutputs = transaction.getOutputs().map(prepareLedgerOutput(accountIndex));
+  const ledgerCertificates = transaction.getCertificates().map(prepareCertificate);
+  const ledgerWithdrawals = transaction.getWithdrawals().map(prepareWithdrawal);
+  const auxiliaryDataHashHex = transaction.getAuxiliaryDataHashHex();
+
+  return {
+    inputs: ledgerAppInputs,
+    outputs: ledgerAppOutputs,
+    certificates: ledgerCertificates,
+    withdrawals: ledgerWithdrawals,
+    fee: transaction.getFee().toString(),
+    ttl: transaction.getTTL()?.toString(),
+    validityIntervalStart: null,
+    auxiliaryData: auxiliaryDataHashHex ?? null,
+  };
+}
+
+/**
+ * returns the formatted transactionInput for ledger cardano app
+ *
+ * @param {TyphonTypes.Input} input
+ * @param {number} accountIndex
+ * @returns {TxInput}
+ */
+const prepareLedgerInput =
+  (accountIndex: number) =>
+  (input: TyphonTypes.Input): SignerTxInput => {
+    const paymentKeyPath =
+      input.address.paymentCredential.type === TyphonTypes.HashType.ADDRESS
+        ? input.address.paymentCredential.bipPath
+        : undefined;
+    return {
+      txHashHex: input.txId,
+      outputIndex: input.index,
+      path: paymentKeyPath
+        ? getBipPathString({
+            account: accountIndex,
+            chain: paymentKeyPath.chain,
+            index: paymentKeyPath.index,
+          })
+        : null,
+    };
+  };
+
+/**
+ * returns the formatted transactionOutput for ledger cardano app
+ *
+ * @param output
+ * @param accountIndex
+ * @returns {TxOutput}
+ */
+const prepareLedgerOutput =
+  (accountIndex: number) =>
+  (output: TyphonTypes.Output): SignerTxOutput => {
+    const isByronAddress = output.address instanceof TyphonAddress.ByronAddress;
+    let isDeviceOwnedAddress = false;
+
+    if (!isByronAddress) {
+      const address = output.address as TyphonTypes.ShelleyAddress;
+      isDeviceOwnedAddress =
+        address.paymentCredential &&
+        address.paymentCredential.type === TyphonTypes.HashType.ADDRESS &&
+        address.paymentCredential.bipPath !== undefined;
+    }
+
+    let destination;
+    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 = {
+        isDeviceOwnedAddress,
+        params: {
+          spendingPath: paymentKeyPathString,
+          stakingPath: stakingKeyPathString,
+        },
+      };
+    } else {
+      const address = output.address;
+      destination = {
+        isDeviceOwnedAddress,
+        params: {
+          addressHex: address.getHex(),
+        },
+      };
+    }
+
+    const tokenBundle = 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,
+    };
+  };
+
+function prepareCertificate(cert: TyphonTypes.Certificate): SignerTxCertificate {
+  if (cert.certType === CertificateType.STAKE_REGISTRATION) {
+    return prepareStakeRegistrationCertificate(cert as TyphonTypes.StakeRegistrationCertificate);
+  } else if (cert.certType === CertificateType.STAKE_DELEGATION) {
+    return prepareStakeDelegationCertificate(cert as TyphonTypes.StakeDelegationCertificate);
+  } else if (cert.certType === CertificateType.STAKE_DE_REGISTRATION) {
+    return prepareStakeDeRegistrationCertificate(
+      cert as TyphonTypes.StakeDeRegistrationCertificate,
+    );
+  } else {
+    throw new Error("Invalid Certificate type");
+  }
+}
+
+function prepareStakeRegistrationCertificate(
+  certificate: TyphonTypes.StakeRegistrationCertificate,
+): {
+  type: "REGISTRATION";
+  params: {
+    stakeCredential: {
+      keyPath: string;
+    };
+  };
+} {
+  if (
+    certificate.stakeCredential.type === TyphonTypes.HashType.ADDRESS &&
+    certificate.stakeCredential.bipPath
+  ) {
+    return {
+      type: "REGISTRATION",
+      params: {
+        stakeCredential: {
+          keyPath: getBipPathString({
+            account: certificate.stakeCredential.bipPath.account,
+            chain: certificate.stakeCredential.bipPath.chain,
+            index: certificate.stakeCredential.bipPath.index,
+          }),
+        },
+      },
+    };
+  } else {
+    throw new Error("Invalid stakeKey type");
+  }
+}
+
+function prepareStakeDelegationCertificate(certificate: TyphonTypes.StakeDelegationCertificate): {
+  type: "DELEGATION";
+  params: {
+    stakeCredential: {
+      keyPath: string;
+    };
+    poolKeyHashHex: string;
+  };
+} {
+  if (
+    certificate.stakeCredential.type === TyphonTypes.HashType.ADDRESS &&
+    certificate.stakeCredential.bipPath
+  ) {
+    return {
+      type: "DELEGATION",
+      params: {
+        stakeCredential: {
+          keyPath: getBipPathString({
+            account: certificate.stakeCredential.bipPath.account,
+            chain: certificate.stakeCredential.bipPath.chain,
+            index: certificate.stakeCredential.bipPath.index,
+          }),
+        },
+        poolKeyHashHex: certificate.poolHash,
+      },
+    };
+  } else {
+    throw new Error("Invalid stakeKey type");
+  }
+}
+
+function prepareStakeDeRegistrationCertificate(certificate: TyphonTypes.Certificate): {
+  type: "DEREGISTRATION";
+  params: {
+    stakeCredential: {
+      keyPath: string;
+    };
+  };
+} {
+  if (
+    certificate.stakeCredential.type === TyphonTypes.HashType.ADDRESS &&
+    certificate.stakeCredential.bipPath
+  ) {
+    return {
+      type: "DEREGISTRATION",
+      params: {
+        stakeCredential: {
+          keyPath: getBipPathString({
+            account: certificate.stakeCredential.bipPath.account,
+            chain: certificate.stakeCredential.bipPath.chain,
+            index: certificate.stakeCredential.bipPath.index,
+          }),
+        },
+      },
+    };
+  } else {
+    throw new Error("Invalid stakeKey type");
+  }
+}
+
+function prepareWithdrawal(withdrawal: TyphonTypes.Withdrawal): SignerTxWithdrawal {
+  if (
+    withdrawal.rewardAccount.stakeCredential.type === TyphonTypes.HashType.ADDRESS &&
+    withdrawal.rewardAccount.stakeCredential.bipPath
+  ) {
+    return {
+      stakeCredential: {
+        keyPath: getBipPathString({
+          account: withdrawal.rewardAccount.stakeCredential.bipPath.account,
+          chain: withdrawal.rewardAccount.stakeCredential.bipPath.chain,
+          index: withdrawal.rewardAccount.stakeCredential.bipPath.index,
+        }),
+      },
+      amount: withdrawal.amount.toString(),
+    };
+  } else {
+    throw new Error("Invalid stakeKey type");
+  }
+}

package/src/utils.ts

@@ -0,0 +1,4 @@
+// the IDs of ledger stake pools to shows in lld and llm
+export const LEDGER_POOL_IDS: Array<string> = [
+  "4a9c9902c9538da900b10b716d5d1b214487455fdb06028b32ffa180",
+];

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../../tsconfig.base",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "module": "commonjs",
+    "downlevelIteration": true,
+    "lib": ["es2020", "dom"],
+    "outDir": "lib"
+  },
+  "include": ["src/**/*"]
+}