@ledgerhq/coin-cardano 0.1.0-next.0

package/src/logic.ts

@@ -0,0 +1,330 @@
+import {
+  CARDANO_COIN_TYPE,
+  CARDANO_PURPOSE,
+  MEMO_LABEL,
+  STAKING_ADDRESS_INDEX,
+  TTL_GAP,
+} from "./constants";
+
+import {
+  utils as TyphonUtils,
+  types as TyphonTypes,
+  address as TyphonAddress,
+} from "@stricahq/typhonjs";
+
+import {
+  CardanoAccount,
+  BipPath,
+  PaymentChain,
+  PaymentCredential,
+  StakeChain,
+  StakeCredential,
+  Token,
+} from "./types";
+import { Bip32PublicKey } from "@stricahq/bip32ed25519";
+import BigNumber from "bignumber.js";
+import { getNetworkParameters } from "./networks";
+import groupBy from "lodash/groupBy";
+import { APITransaction } from "./api/api-types";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import ShelleyTypeAddress from "@stricahq/typhonjs/dist/address/ShelleyTypeAddress";
+import type { OperationType } from "@ledgerhq/types-live";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import bech32 from "bech32";
+
+/**
+ *  returns BipPath object with account, chain and index field for cardano
+ *
+ * @param {string} path
+ */
+export function getBipPathFromString(path: string): BipPath {
+  const regEx = new RegExp(`^${CARDANO_PURPOSE}'/${CARDANO_COIN_TYPE}'/(\\d*)'/([012])/(\\d*)`);
+  const result = path.match(regEx);
+  if (result == null) {
+    throw new Error("Invalid derivation path");
+  }
+  return getBipPath({
+    account: parseInt(result[1]),
+    chain: parseInt(result[2]),
+    index: parseInt(result[3]),
+  });
+}
+
+/**
+ *
+ * @returns true if the account can stake, false otherwise
+ */
+export function canStake(account: CardanoAccount): boolean {
+  return account.balance.gt(0);
+}
+
+/**
+ *
+ * @returns true if account is staked, false otherwise
+ */
+export function isAlreadyStaking(account: CardanoAccount): boolean {
+  return !!account.cardanoResources?.delegation?.poolId;
+}
+
+/**
+ * returns complete bipPath with purpose, coin, account, chain and index for cardano
+ */
+export function getBipPath({
+  account,
+  chain,
+  index,
+}: {
+  account: number;
+  chain: PaymentChain | StakeChain;
+  index: number;
+}): BipPath {
+  return {
+    purpose: CARDANO_PURPOSE,
+    coin: CARDANO_COIN_TYPE,
+    account,
+    chain,
+    index,
+  };
+}
+
+/**
+ * returns bipPathString from account, chain and index for cardano
+ */
+export function getBipPathString({
+  account,
+  chain,
+  index,
+}: {
+  account: number;
+  chain: number;
+  index: number;
+}): string {
+  return `${CARDANO_PURPOSE}'/${CARDANO_COIN_TYPE}'/${account}'/${chain}/${index}`;
+}
+
+export function getExtendedPublicKeyFromHex(keyHex: string): Bip32PublicKey {
+  return Bip32PublicKey.fromBytes(Buffer.from(keyHex, "hex"));
+}
+
+export function getCredentialKey(
+  accountKey: Bip32PublicKey,
+  path: BipPath,
+): { key: string; path: BipPath } {
+  const keyBytes = accountKey.derive(path.chain).derive(path.index).toPublicKey().hash();
+  const pubKeyHex = keyBytes.toString("hex");
+  return {
+    key: pubKeyHex,
+    path,
+  };
+}
+
+/**
+ * returns cardano base address by paymentKey and stakeKey
+ */
+export function getBaseAddress({
+  networkId,
+  paymentCred,
+  stakeCred,
+}: {
+  networkId: number;
+  paymentCred: PaymentCredential;
+  stakeCred: StakeCredential;
+}): TyphonAddress.BaseAddress {
+  const paymentCredential: TyphonTypes.HashCredential = {
+    hash: paymentCred.key,
+    type: TyphonTypes.HashType.ADDRESS,
+    bipPath: paymentCred.path,
+  };
+
+  const stakeCredential: TyphonTypes.HashCredential = {
+    hash: stakeCred.key,
+    type: TyphonTypes.HashType.ADDRESS,
+    bipPath: stakeCred.path,
+  };
+  return new TyphonAddress.BaseAddress(networkId, paymentCredential, stakeCredential);
+}
+
+/**
+ * Returns true if address is a valid
+ *
+ * @param {string} address
+ */
+export const isValidAddress = (address: string, networkId: number): boolean => {
+  if (!address) return false;
+
+  try {
+    const cardanoAddress = TyphonUtils.getAddressFromBech32(address);
+    if (cardanoAddress instanceof ShelleyTypeAddress) {
+      const addressNetworkId = Number(cardanoAddress.getHex().toLowerCase().charAt(1));
+      if (addressNetworkId !== networkId) {
+        return false;
+      }
+    }
+  } catch (error) {
+    return false;
+  }
+  return true;
+};
+
+export const getAbsoluteSlot = function (networkName: string, time: Date): number {
+  const networkParams = getNetworkParameters(networkName);
+  const byronChainEndSlots = networkParams.shelleyStartEpoch * networkParams.byronSlotsPerEpoch;
+  const byronChainEndTime = byronChainEndSlots * networkParams.byronSlotDuration;
+
+  const shelleyChainTime = time.getTime() - networkParams.chainStartTime - byronChainEndTime;
+  const shelleyChainSlots = Math.floor(shelleyChainTime / networkParams.shelleySlotDuration);
+  return byronChainEndSlots + shelleyChainSlots;
+};
+
+/**
+ * Returns the time to live for transaction
+ *
+ * @returns {number}
+ */
+export function getTTL(networkName: string): number {
+  return getAbsoluteSlot(networkName, new Date()) + TTL_GAP;
+}
+
+export function getEpoch(networkName: string, time: Date): number {
+  const networkParams = getNetworkParameters(networkName);
+  const chainTime = time.getTime() - networkParams.chainStartTime;
+  const epoch = Math.floor(
+    chainTime / (networkParams.shelleySlotsPerEpoch * networkParams.shelleySlotDuration),
+  );
+  return epoch;
+}
+
+export function mergeTokens(tokens: Array<TyphonTypes.Token>): Array<TyphonTypes.Token> {
+  return Object.values(groupBy(tokens, t => `${t.policyId}${t.assetName}`)).map(similarTokens => ({
+    policyId: similarTokens[0].policyId,
+    assetName: similarTokens[0].assetName,
+    amount: similarTokens.reduce((total, token) => total.plus(token.amount), new BigNumber(0)),
+  }));
+}
+
+/**
+ * @param { Array<TyphonTypes.Token> } b
+ * @param { Array<TyphonTypes.Token> } a
+ * @returns a - b
+ */
+export function getTokenDiff(
+  a: Array<TyphonTypes.Token>,
+  b: Array<TyphonTypes.Token>,
+): Array<TyphonTypes.Token> {
+  return mergeTokens(a.concat(b.map(t => ({ ...t, amount: t.amount.negated() })))).filter(
+    t => !t.amount.eq(0),
+  );
+}
+
+export function getAccountStakeCredential(xpub: string, index: number): StakeCredential {
+  const accountXPubKey = getExtendedPublicKeyFromHex(xpub);
+  const keyPath = getCredentialKey(
+    accountXPubKey,
+    getBipPath({
+      account: index,
+      chain: StakeChain.stake,
+      index: STAKING_ADDRESS_INDEX,
+    }),
+  );
+  return {
+    key: keyPath.key,
+    path: keyPath.path,
+  };
+}
+
+export function getOperationType({
+  valueChange,
+  fees,
+}: {
+  valueChange: BigNumber;
+  fees: BigNumber;
+}): OperationType {
+  return valueChange.isNegative()
+    ? valueChange.absoluteValue().eq(fees)
+      ? "FEES"
+      : "OUT"
+    : valueChange.isPositive()
+      ? "IN"
+      : "NONE";
+}
+
+export function isTestnet(currency: CryptoCurrency): boolean {
+  return getCryptoCurrencyById(currency.id).isTestnetFor ? true : false;
+}
+
+export function getAccountChange(
+  t: APITransaction,
+  accountCredentialsMap: Record<string, PaymentCredential>,
+): { ada: BigNumber; tokens: Array<Token> } {
+  let accountInputAda = new BigNumber(0);
+  const accountInputTokens: Array<Token> = [];
+  t.inputs.forEach(i => {
+    if (accountCredentialsMap[i.paymentKey]) {
+      accountInputAda = accountInputAda.plus(i.value);
+      accountInputTokens.push(
+        ...i.tokens.map(t => ({
+          assetName: t.assetName,
+          policyId: t.policyId,
+          amount: new BigNumber(t.value),
+        })),
+      );
+    }
+  });
+
+  let accountOutputAda = new BigNumber(0);
+  const accountOutputTokens: Array<Token> = [];
+  t.outputs.forEach(o => {
+    if (accountCredentialsMap[o.paymentKey]) {
+      accountOutputAda = accountOutputAda.plus(o.value);
+      accountOutputTokens.push(
+        ...o.tokens.map(t => ({
+          assetName: t.assetName,
+          policyId: t.policyId,
+          amount: new BigNumber(t.value),
+        })),
+      );
+    }
+  });
+
+  return {
+    ada: accountOutputAda.minus(accountInputAda),
+    tokens: getTokenDiff(accountOutputTokens, accountInputTokens),
+  };
+}
+
+export function getMemoFromTx(tx: APITransaction): string | undefined {
+  let memo;
+  const metadataValue = tx.metadata?.data.find(m => m.label === MEMO_LABEL.toString());
+  if (metadataValue) {
+    try {
+      const parsedValue = JSON.parse(metadataValue.value);
+      if (parsedValue.msg && Array.isArray(parsedValue.msg) && parsedValue.msg.length) {
+        memo = parsedValue.msg.join(", ");
+      }
+      // eslint-disable-next-line no-empty
+    } catch (e) {}
+  }
+  return memo;
+}
+
+export function isHexString(value: string): boolean {
+  const regExp = /^[0-9a-fA-F]+$/;
+  return regExp.test(value);
+}
+
+export function decodeTokenName(assetName: string): string {
+  if (assetName.length > 0) {
+    const bytes = [...Buffer.from(assetName, "hex")];
+    if (bytes.filter(byte => byte <= 32 || byte >= 127).length === 0) {
+      return String.fromCharCode(...bytes);
+    }
+  }
+  return assetName;
+}
+
+export function getBech32PoolId(poolId: string, networkName: string): string {
+  const networkParams = getNetworkParameters(networkName);
+  const words = bech32.toWords(Buffer.from(poolId, "hex"));
+  const encoded = bech32.encode(networkParams.poolIdPrefix, words, 1000);
+  return encoded;
+}

package/src/logic.unit.test.ts

@@ -0,0 +1,39 @@
+import BigNumber from "bignumber.js";
+import { canStake, isAlreadyStaking } from "./logic";
+import { CardanoAccount } from "./types";
+
+describe("canStake", () => {
+  it("should return false when acc has no funds", () => {
+    const accWithNoFunds = {
+      balance: new BigNumber(0),
+    } as CardanoAccount;
+    expect(canStake(accWithNoFunds)).toEqual(false);
+  });
+
+  it("should return true when acc has funds", () => {
+    const accWithFunds = {
+      balance: new BigNumber(1),
+    } as CardanoAccount;
+    expect(canStake(accWithFunds)).toEqual(true);
+  });
+});
+
+describe("isAlreadyStaking", () => {
+  it("should return false when acc isn't delegating", () => {
+    const noResourcesAcc = {} as CardanoAccount;
+    expect(isAlreadyStaking(noResourcesAcc)).toEqual(false);
+    const noDelegationAcc = {
+      cardanoResources: {},
+    } as CardanoAccount;
+    expect(isAlreadyStaking(noDelegationAcc)).toEqual(false);
+    const noPoolIdAcc = { cardanoResources: { delegation: {} } } as CardanoAccount;
+    expect(isAlreadyStaking(noPoolIdAcc)).toEqual(false);
+  });
+
+  it("should return true when acc is delegating", () => {
+    const noResourcesAcc = {
+      cardanoResources: { delegation: { poolId: "itspoolid" } },
+    } as CardanoAccount;
+    expect(isAlreadyStaking(noResourcesAcc)).toEqual(true);
+  });
+});

package/src/networks.ts

@@ -0,0 +1,33 @@
+import type { CardanoLikeNetworkParameters } from "./types";
+
+export const getNetworkParameters = (networkName: string): CardanoLikeNetworkParameters => {
+  if (networkName === "cardano") {
+    return {
+      identifier: "cardano",
+      networkId: 1,
+      chainStartTime: 1506203091000,
+      byronSlotDuration: 20000,
+      byronSlotsPerEpoch: 21600,
+      shelleyStartEpoch: 208,
+      shelleySlotDuration: 1000,
+      shelleySlotsPerEpoch: 432000,
+      addressPrefix: "addr",
+      poolIdPrefix: "pool",
+    };
+  } else if (networkName === "cardano_testnet") {
+    return {
+      identifier: "cardano_testnet",
+      networkId: 0,
+      chainStartTime: 1563999616000,
+      byronSlotDuration: 20000,
+      byronSlotsPerEpoch: 21600,
+      shelleyStartEpoch: 74,
+      shelleySlotDuration: 1000,
+      shelleySlotsPerEpoch: 432000,
+      addressPrefix: "addr_test",
+      poolIdPrefix: "pool",
+    };
+  }
+
+  throw new Error("No network parameters set for " + networkName);
+};

package/src/postSyncPatch.ts

@@ -0,0 +1,42 @@
+/**
+ *  Code reference taken from src/families/ethereum/postSyncPatch.ts
+ */
+
+import type { AccountLike, Operation } from "@ledgerhq/types-live";
+import { CardanoAccount } from "./types";
+
+// we need to preserve ADA pendingOperations because there is no mempool to do this
+// we assume we need to preserve until:
+// - that txid appears in operations
+const postSyncPatchGen = <T extends AccountLike>(
+  initial: T,
+  synced: T,
+  parentPendingOperation?: Operation[],
+): T => {
+  const pendingOperations = initial.pendingOperations || [];
+  if (pendingOperations.length === 0) return synced;
+  const { operations } = synced;
+  synced.pendingOperations = pendingOperations.filter(
+    op =>
+      (!parentPendingOperation || // a child pending parent need to disappear if parent ada op disappear
+        parentPendingOperation.some(o => o.hash === op.hash)) &&
+      !operations.some(o => o.hash === op.hash), // after retain logic, we need operation to appear
+  );
+  return synced;
+};
+
+export const postSyncPatch = (initial: CardanoAccount, synced: CardanoAccount): CardanoAccount => {
+  const acc = postSyncPatchGen(initial, synced);
+  const { subAccounts, pendingOperations } = acc;
+  const initialSubAccounts = initial.subAccounts;
+
+  if (subAccounts && initialSubAccounts) {
+    acc.subAccounts = subAccounts.map(subAccount => {
+      const initialSubAccount = initialSubAccounts.find(a => a.id === subAccount.id);
+      if (!initialSubAccount) return subAccount;
+      return postSyncPatchGen(initialSubAccount, subAccount, pendingOperations);
+    });
+  }
+
+  return acc;
+};

package/src/prepareTransaction.ts

@@ -0,0 +1,41 @@
+import { BigNumber } from "bignumber.js";
+import { types as TyphonTypes, address as TyphonAddress } from "@stricahq/typhonjs";
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+
+import { CardanoAccount, Transaction } from "./types";
+import { buildTransaction } from "./buildTransaction";
+import { AccountBridge } from "@ledgerhq/types-live";
+
+/**
+ * Prepare transaction before checking status
+ *
+ * @param {Account} account
+ * @param {Transaction} transaction
+ */
+export const prepareTransaction: AccountBridge<
+  Transaction,
+  CardanoAccount
+>["prepareTransaction"] = async (account, transaction) => {
+  let patch = {};
+  try {
+    const cardanoTransaction = await buildTransaction(account, transaction);
+    const transactionFees = cardanoTransaction.getFee();
+    const transactionAmount = transaction.subAccountId
+      ? transaction.amount
+      : cardanoTransaction
+          .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));
+
+    patch = { fees: transactionFees, amount: transactionAmount };
+  } catch (error) {
+    patch = { fees: new BigNumber(0), amount: transaction.amount };
+  }
+
+  return defaultUpdateTransaction(transaction, patch);
+};

package/src/serialization.ts

@@ -0,0 +1,219 @@
+import { BigNumber } from "bignumber.js";
+import type {
+  BipPath,
+  BipPathRaw,
+  CardanoDelegation,
+  CardanoDelegationRaw,
+  CardanoAccount,
+  CardanoAccountRaw,
+  CardanoOutput,
+  CardanoOutputRaw,
+  CardanoResources,
+  CardanoResourcesRaw,
+  PaymentCredential,
+  PaymentCredentialRaw,
+  ProtocolParams,
+  ProtocolParamsRaw,
+  Token,
+  TokenRaw,
+} from "./types";
+import { Account, AccountRaw } from "@ledgerhq/types-live";
+
+function toTokenRaw({ assetName, policyId, amount }: Token): TokenRaw {
+  return {
+    assetName,
+    policyId,
+    amount: amount.toString(),
+  };
+}
+
+function fromTokenRaw({ assetName, policyId, amount }: TokenRaw): Token {
+  return {
+    assetName,
+    policyId,
+    amount: new BigNumber(amount),
+  };
+}
+
+function toBipPathRaw({ purpose, coin, account, chain, index }: BipPath): BipPathRaw {
+  return {
+    purpose,
+    coin,
+    account,
+    chain,
+    index,
+  };
+}
+
+function fromBipPathRaw({ purpose, coin, account, chain, index }: BipPathRaw): BipPath {
+  return {
+    purpose,
+    coin,
+    account,
+    chain,
+    index,
+  };
+}
+
+function toPaymentCredentialRaw(r: PaymentCredential): PaymentCredentialRaw {
+  return {
+    isUsed: r.isUsed,
+    key: r.key,
+    path: toBipPathRaw(r.path),
+  };
+}
+
+function fromPaymentCredentialRaw(r: PaymentCredentialRaw): PaymentCredential {
+  return {
+    isUsed: r.isUsed,
+    key: r.key,
+    path: fromBipPathRaw(r.path),
+  };
+}
+
+function toCardanoOutputRaw({
+  hash,
+  index,
+  address,
+  amount,
+  tokens,
+  paymentCredential,
+}: CardanoOutput): CardanoOutputRaw {
+  return {
+    hash,
+    index,
+    address,
+    amount: amount.toString(),
+    tokens: tokens.map(toTokenRaw),
+    paymentCredential,
+  };
+}
+
+function fromCardanoOutputRaw({
+  hash,
+  index,
+  address,
+  amount,
+  tokens,
+  paymentCredential,
+}: CardanoOutputRaw): CardanoOutput {
+  return {
+    hash,
+    index,
+    address,
+    amount: new BigNumber(amount),
+    tokens: tokens.map(fromTokenRaw),
+    paymentCredential,
+  };
+}
+
+function toProtocolParamsRaw({
+  minFeeA,
+  minFeeB,
+  stakeKeyDeposit,
+  lovelacePerUtxoWord,
+  collateralPercent,
+  priceSteps,
+  priceMem,
+  languageView,
+}: ProtocolParams): ProtocolParamsRaw {
+  return {
+    minFeeA,
+    minFeeB,
+    stakeKeyDeposit,
+    lovelacePerUtxoWord,
+    collateralPercent,
+    priceSteps,
+    priceMem,
+    languageView,
+  };
+}
+
+function fromProtocolParamsRaw({
+  minFeeA,
+  minFeeB,
+  stakeKeyDeposit,
+  lovelacePerUtxoWord,
+  collateralPercent,
+  priceSteps,
+  priceMem,
+  languageView,
+}: ProtocolParamsRaw): ProtocolParams {
+  return {
+    minFeeA,
+    minFeeB,
+    stakeKeyDeposit,
+    lovelacePerUtxoWord,
+    collateralPercent,
+    priceSteps,
+    priceMem,
+    languageView,
+  };
+}
+
+function toDelegationRaw({
+  status,
+  poolId,
+  ticker,
+  name,
+  rewards,
+}: CardanoDelegation): CardanoDelegationRaw {
+  return {
+    status,
+    poolId,
+    ticker,
+    name,
+    rewards: rewards.toString(),
+  };
+}
+
+function fromDelegationRaw({
+  status,
+  poolId,
+  ticker,
+  name,
+  rewards,
+}: CardanoDelegationRaw): CardanoDelegation {
+  return {
+    status,
+    poolId,
+    ticker,
+    name,
+    rewards: new BigNumber(rewards),
+  };
+}
+
+export function toCardanoResourceRaw(r: CardanoResources): CardanoResourcesRaw {
+  return {
+    internalCredentials: r.internalCredentials.map(toPaymentCredentialRaw),
+    externalCredentials: r.externalCredentials.map(toPaymentCredentialRaw),
+    delegation: r.delegation ? toDelegationRaw(r.delegation) : undefined,
+    utxos: r.utxos.map(toCardanoOutputRaw),
+    protocolParams: toProtocolParamsRaw(r.protocolParams),
+  };
+}
+
+export function fromCardanoResourceRaw(r: CardanoResourcesRaw): CardanoResources {
+  return {
+    internalCredentials: r.internalCredentials.map(fromPaymentCredentialRaw),
+    externalCredentials: r.externalCredentials.map(fromPaymentCredentialRaw),
+    delegation: r.delegation ? fromDelegationRaw(r.delegation) : undefined,
+    utxos: r.utxos.map(fromCardanoOutputRaw),
+    protocolParams: fromProtocolParamsRaw(r.protocolParams),
+  };
+}
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw): void {
+  const cardanoAccount = account as CardanoAccount;
+  if (cardanoAccount.cardanoResources) {
+    (accountRaw as CardanoAccountRaw).cardanoResources = toCardanoResourceRaw(
+      cardanoAccount.cardanoResources,
+    );
+  }
+}
+
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
+  const cardanoResourcesRaw = (accountRaw as CardanoAccountRaw).cardanoResources;
+  if (cardanoResourcesRaw)
+    (account as CardanoAccount).cardanoResources = fromCardanoResourceRaw(cardanoResourcesRaw);
+}