@ledgerhq/coin-cardano 0.1.0-next.0

package/src/api/api-types.ts

@@ -0,0 +1,115 @@
+import { ProtocolParams } from "../types";
+
+type APIToken = { assetName: string; policyId: string; value: string };
+
+type APIMetadata = { label: string; value: string };
+
+export enum HashType {
+  ADDRESS = "ADDRESS",
+  SCRIPT = "SCRIPT",
+}
+
+export type StakeCredential = {
+  key: string;
+  type: HashType;
+};
+
+export type StakeKeyRegistrationCertificate = {
+  index: number;
+  stakeCredential: StakeCredential;
+};
+
+export type StakeKeyDeRegistrationCertificate = {
+  index: number;
+  stakeCredential: StakeCredential;
+};
+
+export type StakeDelegationCertificate = {
+  index: number;
+  poolKeyHash: string;
+  stakeCredential: StakeCredential;
+};
+
+export type TransactionCertificate =
+  | StakeKeyRegistrationCertificate
+  | StakeKeyDeRegistrationCertificate
+  | StakeDelegationCertificate;
+
+export type TransactionCertificates = {
+  stakeRegistrations: Array<StakeKeyRegistrationCertificate>;
+  stakeDeRegistrations: Array<StakeKeyDeRegistrationCertificate>;
+  stakeDelegations: Array<StakeDelegationCertificate>;
+};
+
+export type APITransaction = {
+  fees: string;
+  hash: string;
+  timestamp: string;
+  blockHeight: number;
+  inputs: Array<{
+    txId: string;
+    index: number;
+    address: string;
+    value: string;
+    paymentKey: string;
+    tokens: Array<APIToken>;
+  }>;
+  certificate: TransactionCertificates;
+  outputs: Array<{
+    address: string;
+    value: string;
+    paymentKey: string;
+    tokens: Array<APIToken>;
+  }>;
+  metadata?: {
+    hash: string;
+    data: Array<APIMetadata>;
+  };
+  withdrawals?: Array<{
+    stakeCredential: StakeCredential;
+    amount: string;
+  }>;
+};
+
+export type APINetworkInfo = {
+  protocolParams: ProtocolParams;
+};
+
+export type APIDelegation = {
+  status: boolean;
+  stakeCredential: {
+    key: string;
+    type: string;
+  };
+  stake: string;
+  rewardsAvailable: string;
+  rewardsWithdrawn: string;
+  poolInfo: {
+    poolId: string;
+    name: string;
+    ticker: string;
+  };
+};
+
+export type StakePool = {
+  poolId: string;
+  name: string | undefined;
+  ticker: string | undefined;
+  website: string | undefined;
+  margin: string;
+  cost: string;
+  pledge: string;
+  retiredEpoch: number | undefined;
+  liveStake: string;
+};
+
+export type APIGetPoolList = {
+  pageNo: number;
+  limit: number;
+  count: number;
+  pools: Array<StakePool>;
+};
+
+export type APIGetPoolsDetail = {
+  pools: Array<StakePool>;
+};

package/src/api/getDelegationInfo.ts

@@ -0,0 +1,39 @@
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import BigNumber from "bignumber.js";
+import network from "@ledgerhq/live-network/network";
+import { CARDANO_API_ENDPOINT, CARDANO_TESTNET_API_ENDPOINT } from "../constants";
+import { isTestnet } from "../logic";
+import { CardanoDelegation } from "../types";
+import { APIDelegation } from "./api-types";
+
+async function fetchDelegationInfo(
+  currency: CryptoCurrency,
+  stakeKey: string,
+): Promise<APIDelegation> {
+  const res = await network({
+    method: "GET",
+    url: isTestnet(currency)
+      ? `${CARDANO_TESTNET_API_ENDPOINT}/v1/delegation`
+      : `${CARDANO_API_ENDPOINT}/v1/delegation`,
+    params: {
+      stakeKey,
+    },
+  });
+  return res && res.data && (res.data.delegation as APIDelegation);
+}
+
+export async function getDelegationInfo(
+  currency: CryptoCurrency,
+  stakeKey: string,
+): Promise<CardanoDelegation | undefined> {
+  const res = await fetchDelegationInfo(currency, stakeKey);
+  return (
+    res && {
+      status: res.status,
+      poolId: res.poolInfo?.poolId,
+      ticker: res.poolInfo?.ticker,
+      name: res.poolInfo?.name,
+      rewards: new BigNumber(res.rewardsAvailable),
+    }
+  );
+}

package/src/api/getNetworkInfo.ts

@@ -0,0 +1,34 @@
+import network from "@ledgerhq/live-network/network";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { CARDANO_API_ENDPOINT, CARDANO_TESTNET_API_ENDPOINT } from "../constants";
+import { getEpoch, isTestnet } from "../logic";
+import { CardanoAccount } from "../types";
+import { APINetworkInfo } from "./api-types";
+
+async function fetchNetworkInfo(currency: CryptoCurrency): Promise<APINetworkInfo> {
+  const res = await network({
+    method: "GET",
+    url: isTestnet(currency)
+      ? `${CARDANO_TESTNET_API_ENDPOINT}/v1/network/info`
+      : `${CARDANO_API_ENDPOINT}/v1/network/info`,
+  });
+  return res && (res.data as APINetworkInfo);
+}
+
+export async function getNetworkInfo(
+  a: CardanoAccount | undefined,
+  currency: CryptoCurrency,
+): Promise<APINetworkInfo> {
+  if (a && a.cardanoResources) {
+    const currencyId = a.currency.id;
+    const currentEpoch = getEpoch(currencyId, new Date());
+    const lastSyncedEpoch = getEpoch(currencyId, a.lastSyncDate);
+
+    if (currentEpoch === lastSyncedEpoch) {
+      return {
+        protocolParams: a.cardanoResources.protocolParams,
+      };
+    }
+  }
+  return fetchNetworkInfo(currency);
+}

package/src/api/getPools.ts

@@ -0,0 +1,35 @@
+import { APIGetPoolList, APIGetPoolsDetail } from "./api-types";
+import { isTestnet } from "../logic";
+import { CARDANO_API_ENDPOINT, CARDANO_TESTNET_API_ENDPOINT } from "../constants";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import network from "@ledgerhq/live-network/network";
+
+export async function fetchPoolList(
+  currency: CryptoCurrency,
+  search: string,
+  pageNo: number,
+  limit: number,
+): Promise<APIGetPoolList> {
+  const res = await network({
+    method: "GET",
+    url: isTestnet(currency)
+      ? `${CARDANO_TESTNET_API_ENDPOINT}/v1/pool/list`
+      : `${CARDANO_API_ENDPOINT}/v1/pool/list`,
+    params: { search, pageNo, limit },
+  });
+  return res && (res.data as APIGetPoolList);
+}
+
+export async function fetchPoolDetails(
+  currency: CryptoCurrency,
+  poolIds: Array<string>,
+): Promise<APIGetPoolsDetail> {
+  const res = await network({
+    method: "GET",
+    url: isTestnet(currency)
+      ? `${CARDANO_TESTNET_API_ENDPOINT}/v1/pool/detail`
+      : `${CARDANO_API_ENDPOINT}/v1/pool/detail`,
+    params: { poolIds },
+  });
+  return res && (res.data as APIGetPoolsDetail);
+}

package/src/api/getTransactions.ts

@@ -0,0 +1,218 @@
+import network from "@ledgerhq/live-network/network";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { Bip32PublicKey } from "@stricahq/bip32ed25519";
+import chunk from "lodash/chunk";
+import range from "lodash/range";
+import { getEnv } from "@ledgerhq/live-env";
+import { CARDANO_API_ENDPOINT, CARDANO_TESTNET_API_ENDPOINT } from "../constants";
+import { getBipPath, getCredentialKey, getExtendedPublicKeyFromHex, isTestnet } from "../logic";
+import { CardanoAccount, PaymentChain, PaymentCredential } from "../types";
+import * as ApiTypes from "./api-types";
+import { APITransaction } from "./api-types";
+
+async function fetchTransactions(
+  paymentKeys: Array<string>,
+  pageNo: number,
+  blockHeight: number,
+  currency: CryptoCurrency,
+): Promise<{
+  pageNo: number;
+  limit: number;
+  blockHeight: number;
+  transactions: Array<APITransaction>;
+}> {
+  const res = await network({
+    method: "POST",
+    url: isTestnet(currency)
+      ? `${CARDANO_TESTNET_API_ENDPOINT}/v1/transaction`
+      : `${CARDANO_API_ENDPOINT}/v1/transaction`,
+    data: {
+      paymentKeys,
+      pageNo,
+      blockHeight,
+    },
+  });
+  return res.data;
+}
+
+async function getAllTransactionsByKeys(
+  paymentKeys: Array<string>,
+  blockHeight: number,
+  currency: CryptoCurrency,
+): Promise<{
+  transactions: Array<ApiTypes.APITransaction>;
+  blockHeight: number;
+}> {
+  const transactions: Array<ApiTypes.APITransaction> = [];
+  let latestBlockHeight = 0;
+  let isAllTrxFetched = false;
+  let pageNo = 1;
+
+  while (!isAllTrxFetched) {
+    const res = await fetchTransactions(paymentKeys, pageNo, blockHeight, currency);
+    transactions.push(...res.transactions);
+    latestBlockHeight = Math.max(res.blockHeight, latestBlockHeight);
+    isAllTrxFetched = res.transactions.length < res.limit;
+    pageNo += 1;
+  }
+  return {
+    transactions,
+    blockHeight: latestBlockHeight,
+  };
+}
+
+async function getSyncedTransactionsByChain(
+  accountPubKey: Bip32PublicKey,
+  accountIndex: number,
+  chainType: PaymentChain,
+  blockHeight: number,
+  initialPaymentCredentials: Array<PaymentCredential>,
+  currency: CryptoCurrency,
+): Promise<{
+  transactions: Array<ApiTypes.APITransaction>;
+  latestBlockHeight: number;
+  paymentCredentials: Array<PaymentCredential>;
+}> {
+  const keyChainRange = getEnv("KEYCHAIN_OBSERVABLE_RANGE") || 20;
+
+  // credentialsMap for efficient use
+  const initialPaymentCredentialMap: Record<string, PaymentCredential> = {};
+  let maxUsedKeyIndex = -1;
+  initialPaymentCredentials.forEach(cred => {
+    initialPaymentCredentialMap[cred.key] = cred;
+    if (cred.isUsed) maxUsedKeyIndex = cred.path.index;
+  });
+
+  const transactions: Array<ApiTypes.APITransaction> = [];
+  let latestBlockHeight = 0;
+
+  // fetch transactions for existing keys
+  const trxsRes = await Promise.all(
+    chunk(Object.keys(initialPaymentCredentialMap), keyChainRange).map(keys =>
+      getAllTransactionsByKeys(keys, blockHeight, currency),
+    ),
+  );
+  trxsRes.forEach(txRes => {
+    transactions.push(...txRes.transactions);
+    latestBlockHeight = Math.max(latestBlockHeight, txRes.blockHeight);
+  });
+
+  // fetch transactions for new avaialble keys
+  let newPaymentCredentialsMap: Record<string, PaymentCredential> = {};
+  let lastSyncedKeyIndex = initialPaymentCredentials.length
+    ? initialPaymentCredentials[initialPaymentCredentials.length - 1].path.index
+    : -1;
+  let syncToKeyIndex = maxUsedKeyIndex + keyChainRange;
+  while (syncToKeyIndex !== lastSyncedKeyIndex) {
+    const currentPaymentKeysMap: Record<string, PaymentCredential> = {};
+    range(lastSyncedKeyIndex + 1, syncToKeyIndex + 1, 1).forEach(keyIndex => {
+      const keyPath = getCredentialKey(
+        accountPubKey,
+        getBipPath({
+          account: accountIndex,
+          chain: chainType,
+          index: keyIndex,
+        }),
+      );
+      currentPaymentKeysMap[keyPath.key] = {
+        isUsed: false,
+        key: keyPath.key,
+        path: keyPath.path,
+      };
+    });
+    const trxRes = await getAllTransactionsByKeys(
+      Object.keys(currentPaymentKeysMap),
+      blockHeight,
+      currency,
+    );
+    transactions.push(...trxRes.transactions);
+
+    lastSyncedKeyIndex = syncToKeyIndex;
+    latestBlockHeight = Math.max(latestBlockHeight, trxRes.blockHeight);
+    newPaymentCredentialsMap = Object.assign({}, newPaymentCredentialsMap, currentPaymentKeysMap);
+    maxUsedKeyIndex = trxRes.transactions.reduce(
+      (maxIndexA, { inputs, outputs }) =>
+        [...inputs, ...outputs].reduce(
+          (maxIndexB, io) =>
+            Math.max(newPaymentCredentialsMap[io.paymentKey]?.path.index || -1, maxIndexB),
+          maxIndexA,
+        ),
+      maxUsedKeyIndex,
+    );
+    syncToKeyIndex = maxUsedKeyIndex + keyChainRange;
+  }
+
+  const availablePaymentCredentialsMap = {
+    ...initialPaymentCredentialMap,
+    ...newPaymentCredentialsMap,
+  };
+  transactions.forEach(trx => {
+    [...trx.inputs, ...trx.outputs].forEach(io => {
+      if (availablePaymentCredentialsMap[io.paymentKey]) {
+        availablePaymentCredentialsMap[io.paymentKey].isUsed = true;
+      }
+    });
+  });
+
+  return {
+    transactions,
+    latestBlockHeight,
+    paymentCredentials: Object.values(availablePaymentCredentialsMap).sort(
+      (aCred, bCred) => aCred.path.index - bCred.path.index,
+    ),
+  };
+}
+
+export async function getTransactions(
+  xpub: string,
+  accountIndex: number,
+  initialAccount: CardanoAccount | undefined,
+  blockHeight: number,
+  currency: CryptoCurrency,
+): Promise<{
+  transactions: Array<ApiTypes.APITransaction>;
+  blockHeight: number;
+  externalCredentials: Array<PaymentCredential>;
+  internalCredentials: Array<PaymentCredential>;
+}> {
+  const accountPubKey = getExtendedPublicKeyFromHex(xpub);
+  const oldExternalCredentials = initialAccount?.cardanoResources?.externalCredentials || [];
+  const oldInternalCredentials = initialAccount?.cardanoResources?.internalCredentials || [];
+
+  const [
+    {
+      transactions: externalKeyTransactions,
+      latestBlockHeight: aBlockHeight,
+      paymentCredentials: externalCredentials,
+    },
+    {
+      transactions: internalKeyTransactions,
+      latestBlockHeight: bBlockHeight,
+      paymentCredentials: internalCredentials,
+    },
+  ] = await Promise.all([
+    getSyncedTransactionsByChain(
+      accountPubKey,
+      accountIndex,
+      PaymentChain.external,
+      blockHeight,
+      oldExternalCredentials,
+      currency,
+    ),
+    getSyncedTransactionsByChain(
+      accountPubKey,
+      accountIndex,
+      PaymentChain.internal,
+      blockHeight,
+      oldInternalCredentials,
+      currency,
+    ),
+  ]);
+
+  return {
+    transactions: [...externalKeyTransactions, ...internalKeyTransactions],
+    blockHeight: Math.max(aBlockHeight, bBlockHeight),
+    externalCredentials,
+    internalCredentials,
+  };
+}

package/src/api/submitTransaction.ts

@@ -0,0 +1,24 @@
+import network from "@ledgerhq/live-network/network";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { CARDANO_API_ENDPOINT, CARDANO_TESTNET_API_ENDPOINT } from "../constants";
+import { isTestnet } from "../logic";
+import { APITransaction } from "./api-types";
+
+export async function submitTransaction({
+  transaction,
+  currency,
+}: {
+  transaction: string;
+  currency: CryptoCurrency;
+}): Promise<APITransaction> {
+  const res = await network({
+    method: "POST",
+    url: isTestnet(currency)
+      ? `${CARDANO_TESTNET_API_ENDPOINT}/v1/transaction/submit`
+      : `${CARDANO_API_ENDPOINT}/v1/transaction/submit`,
+    data: {
+      transaction: transaction,
+    },
+  });
+  return res.data.transaction;
+}

package/src/bridge/index.ts

@@ -0,0 +1,69 @@
+import {
+  defaultUpdateTransaction,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+  makeSync,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import type { CardanoAccount, Transaction, TransactionStatus } from "../types";
+import { assignToAccountRaw, assignFromAccountRaw } from "../serialization";
+import { estimateMaxSpendable } from "../estimateMaxSpendable";
+import { getTransactionStatus } from "../getTransactionStatus";
+import { prepareTransaction } from "../prepareTransaction";
+import { createTransaction } from "../createTransaction";
+import { makeGetAccountShape } from "../synchronisation";
+import { buildSignOperation } from "../signOperation";
+import { postSyncPatch } from "../postSyncPatch";
+import { CardanoSigner } from "../signer";
+import { broadcast } from "../broadcast";
+import resolver from "../hw-getAddress";
+
+export function buildCurrencyBridge(signerContext: SignerContext<CardanoSigner>): CurrencyBridge {
+  const getAddress = resolver(signerContext);
+  const scanAccounts = makeScanAccounts({
+    getAccountShape: makeGetAccountShape(signerContext),
+    getAddressFn: getAddressWrapper(getAddress),
+  });
+
+  return {
+    scanAccounts,
+    preload: async () => ({}),
+    hydrate: () => {},
+  };
+}
+
+export function buildAccountBridge(
+  signerContext: SignerContext<CardanoSigner>,
+): AccountBridge<Transaction, CardanoAccount, TransactionStatus> {
+  const sync = makeSync({
+    getAccountShape: makeGetAccountShape(signerContext),
+    postSync: postSyncPatch,
+  });
+
+  const getAddress = resolver(signerContext);
+
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+
+  return {
+    estimateMaxSpendable,
+    createTransaction,
+    updateTransaction: defaultUpdateTransaction,
+    getTransactionStatus,
+    prepareTransaction,
+    sync,
+    receive,
+    signOperation: buildSignOperation(signerContext),
+    broadcast,
+    assignToAccountRaw,
+    assignFromAccountRaw,
+  };
+}
+
+export function createBridges(signerContext: SignerContext<CardanoSigner>) {
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext),
+    accountBridge: buildAccountBridge(signerContext),
+  };
+}

package/src/bridge.integration.test.ts

@@ -0,0 +1,113 @@
+import BigNumber from "bignumber.js";
+import { cardanoRawAccount1 } from "./datasets/rawAccount.1";
+import { cardanoScanAccounts } from "./datasets/scanAccounts";
+import { CardanoInvalidPoolId, CardanoMinAmountError } from "./errors";
+import { fromTransactionRaw } from "./transaction";
+import type { Transaction } from "./types";
+import type { DatasetTest } from "@ledgerhq/types-live";
+
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    cardano_testnet: {
+      scanAccounts: cardanoScanAccounts,
+      accounts: [
+        {
+          raw: cardanoRawAccount1,
+          transactions: [
+            {
+              name: "amount less then minimum",
+              transaction: fromTransactionRaw({
+                family: "cardano",
+                recipient:
+                  "addr_test1qpl90kc2jl5kr9tev0s7vays9yhwcdnq8nlylyk4dqsdq3g466elxnxwrzwq72pvp5akenj30t5s9et7frfvrxxx8xcsxrzs87",
+                amount: "0.1",
+                mode: "send",
+                poolId: undefined,
+              }),
+              expectedStatus: {
+                amount: new BigNumber("0.1"),
+                errors: {
+                  amount: new CardanoMinAmountError(),
+                },
+              },
+            },
+            /* // FIXME broken test
+            {
+              name: "token amount more than balance",
+              transaction: fromTransactionRaw({
+                family: "cardano",
+                recipient:
+                  "addr_test1qpl90kc2jl5kr9tev0s7vays9yhwcdnq8nlylyk4dqsdq3g466elxnxwrzwq72pvp5akenj30t5s9et7frfvrxxx8xcsxrzs87",
+                amount: "101",
+                subAccountId:
+                  "js:2:cardano_testnet:806499588e0c4a58f4119f7e6e096bf42c3f774a528d2acec9e82ceebf87d1ceb3d4f3622dd2c77c65cc89c123f79337db22cf8a69f122e36dab1bf5083bf82d:cardano+cardano_testnet%2Fnative%2F47be64fcc8a7fe5321b976282ce4e43e4d29015f6613cfabcea28eab54657374",
+                mode: "send",
+                poolId: undefined,
+              }),
+              expectedStatus: {
+                amount: new BigNumber("101"),
+                errors: {
+                  amount: new NotEnoughBalance(),
+                },
+              },
+            },
+            {
+              name: "send max token",
+              transaction: fromTransactionRaw({
+                family: "cardano",
+                recipient:
+                  "addr_test1qpl90kc2jl5kr9tev0s7vays9yhwcdnq8nlylyk4dqsdq3g466elxnxwrzwq72pvp5akenj30t5s9et7frfvrxxx8xcsxrzs87",
+                amount: "0",
+                subAccountId:
+                  "js:2:cardano_testnet:806499588e0c4a58f4119f7e6e096bf42c3f774a528d2acec9e82ceebf87d1ceb3d4f3622dd2c77c65cc89c123f79337db22cf8a69f122e36dab1bf5083bf82d:cardano+cardano_testnet%2Fnative%2F47be64fcc8a7fe5321b976282ce4e43e4d29015f6613cfabcea28eab54657374",
+                mode: "send",
+                useAllAmount: true,
+                poolId: undefined,
+              }),
+              expectedStatus: {
+                amount: new BigNumber("100"),
+                totalSpent: new BigNumber("100"),
+                errors: {},
+                warnings: {},
+              },
+            },
+            */
+            {
+              name: "delegate to invalid poolId",
+              transaction: fromTransactionRaw({
+                family: "cardano",
+                recipient: "",
+                amount: "0",
+                mode: "delegate",
+                poolId: "efae72c07a26e4542ba55ef59d35ad45ffaaac312865e3a758ede",
+              }),
+              expectedStatus: {
+                errors: {
+                  poolId: new CardanoInvalidPoolId(),
+                },
+              },
+            },
+            {
+              name: "delegate valid poolId",
+              transaction: fromTransactionRaw({
+                family: "cardano",
+                recipient: "",
+                amount: "0",
+                mode: "delegate",
+                poolId: "efae72c07a26e4542ba55ef59d35ad45ffaaac312865e3a758ede997",
+              }),
+              expectedStatus: {},
+            },
+          ],
+        },
+      ],
+    },
+  },
+};
+
+describe("Cardano bridge", () => {
+  test.todo(
+    "This is an empty test to make jest command pass. Remove it once there is a real test.",
+  );
+});

package/src/broadcast.ts

@@ -0,0 +1,21 @@
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import { submitTransaction } from "./api/submitTransaction";
+import { Transaction } from "./types";
+
+/**
+ * Broadcast the signed transaction
+ * @param {signature: string, operation: string} signedOperation
+ */
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
+  signedOperation,
+  account,
+}) => {
+  const signedTx = signedOperation.signature;
+  const pendingTransaction = await submitTransaction({
+    transaction: signedTx,
+    currency: account.currency,
+  });
+
+  return patchOperationWithHash(signedOperation.operation, pendingTransaction.hash);
+};