@ledgerhq/coin-cardano 0.1.0-next.0

package/src/signOperation.ts

@@ -0,0 +1,82 @@
+import { Observable } from "rxjs";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { Bip32PublicKey } from "@stricahq/bip32ed25519";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { AccountBridge, SignOperationEvent } from "@ledgerhq/types-live";
+import { Transaction as TyphonTransaction, types as TyphonTypes } from "@stricahq/typhonjs";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import type { CardanoAccount, Transaction } from "./types";
+import { getExtendedPublicKeyFromHex } from "./logic";
+import { buildTransaction } from "./buildTransaction";
+import { getNetworkParameters } from "./networks";
+import { CardanoSigner, Witness } from "./signer";
+import typhonSerializer from "./typhonSerializer";
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const buildSignOperation =
+  (
+    signerContext: SignerContext<CardanoSigner>,
+  ): AccountBridge<Transaction, CardanoAccount>["signOperation"] =>
+  ({ account, deviceId, transaction }): Observable<SignOperationEvent> =>
+    new Observable(o => {
+      async function main() {
+        o.next({ type: "device-signature-requested" });
+
+        if (!transaction.fees) {
+          throw new FeeNotLoaded();
+        }
+
+        const unsignedTransaction = await buildTransaction(account, transaction);
+        const signerTransaction = typhonSerializer(unsignedTransaction, account.index);
+
+        const networkParams = getNetworkParameters(account.currency.id);
+        const signedData = await signerContext(deviceId, signer =>
+          signer.sign({
+            transaction: signerTransaction,
+            networkParams,
+          }),
+        );
+
+        const accountPubKey = getExtendedPublicKeyFromHex(account.xpub as string);
+        const signed = signTx(unsignedTransaction, accountPubKey, signedData.witnesses);
+
+        o.next({ type: "device-signature-granted" });
+
+        const operation = buildOptimisticOperation(account, unsignedTransaction, transaction);
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature: signed.payload,
+          },
+        });
+      }
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });
+
+/**
+ * Adds signatures to unsigned transaction
+ */
+const signTx = (
+  unsignedTransaction: TyphonTransaction,
+  accountKey: Bip32PublicKey,
+  witnesses: Array<Witness>,
+) => {
+  witnesses.forEach(witness => {
+    const [, , , chainType, index] = witness.path;
+    const publicKey = accountKey.derive(chainType).derive(index).toPublicKey().toBytes();
+    const vKeyWitness: TyphonTypes.VKeyWitness = {
+      signature: Buffer.from(witness.witnessSignatureHex, "hex"),
+      publicKey: Buffer.from(publicKey),
+    };
+    unsignedTransaction.addWitness(vKeyWitness);
+  });
+
+  return unsignedTransaction.buildTransaction();
+};

package/src/signer.ts

@@ -0,0 +1,98 @@
+import { CardanoLikeNetworkParameters } from "./types";
+
+export type CardanoAddress = {
+  addressHex: string;
+};
+// Coming from @cardano-foundation/ledgerjs-hw-app-cardano code (type SignedTransactionData)
+type BIP32Path = Array<number>;
+export type Witness = {
+  path: BIP32Path;
+  witnessSignatureHex: string;
+};
+export type CardanoSignature = {
+  txHashHex: string;
+  witnesses: Array<Witness>;
+};
+// Coming from @cardano-foundation/ledgerjs-hw-app-cardano code (type ExtendedPublicKey)
+export type CardanoExtendedPublicKey = {
+  publicKeyHex: string;
+  chainCodeHex: string;
+};
+export type GetAddressRequest = {
+  path: string;
+  stakingPathString: string;
+  networkParams: CardanoLikeNetworkParameters;
+  verify?: boolean;
+};
+
+export type SignerTxInput = {
+  txHashHex: string;
+  outputIndex: number;
+  path: string | null;
+};
+export type SignerTxOutput = {
+  amount: string;
+  destination:
+    | {
+        isDeviceOwnedAddress: false;
+        params: {
+          addressHex: string;
+        };
+      }
+    | {
+        isDeviceOwnedAddress: true;
+        params: {
+          spendingPath: string;
+          stakingPath: string;
+        };
+      };
+  tokenBundle: Array<{
+    policyIdHex: string;
+    tokens: Array<{
+      assetNameHex: string;
+      amount: string;
+    }>;
+  }>;
+};
+export type SignerTxCertificate =
+  | {
+      type: "REGISTRATION" | "DEREGISTRATION";
+      params: {
+        stakeCredential: {
+          keyPath: string;
+        };
+      };
+    }
+  | {
+      type: "DELEGATION";
+      params: {
+        stakeCredential: {
+          keyPath: string;
+        };
+        poolKeyHashHex: string;
+      };
+    };
+export type SignerTxWithdrawal = {
+  stakeCredential: {
+    keyPath: string;
+  };
+  amount: string;
+};
+export type SignerTransaction = {
+  inputs: Array<SignerTxInput>;
+  outputs: Array<SignerTxOutput>;
+  certificates: Array<SignerTxCertificate>;
+  withdrawals: Array<SignerTxWithdrawal>;
+  fee: string;
+  ttl?: string;
+  auxiliaryData: string | null;
+};
+export type CardanoSignRequest = {
+  transaction: SignerTransaction;
+  networkParams: CardanoLikeNetworkParameters;
+};
+export interface CardanoSigner {
+  getAddress(addressRequest: GetAddressRequest): Promise<CardanoAddress>;
+  getPublicKey(accountPath: string): Promise<CardanoExtendedPublicKey>;
+  sign(signRequest: CardanoSignRequest): Promise<CardanoSignature>;
+}

package/src/specs.ts

@@ -0,0 +1,253 @@
+import expect from "expect";
+import type { AppSpec } from "@ledgerhq/coin-framework/bot/types";
+import type { CardanoAccount, CardanoOperationExtra, CardanoResources, Transaction } from "./types";
+import { botTest, genericTestDestination, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import { DeviceModelId } from "@ledgerhq/devices";
+import BigNumber from "bignumber.js";
+import invariant from "invariant";
+import { utils as TyphonUtils } from "@stricahq/typhonjs";
+import { mergeTokens } from "./logic";
+import { formatCurrencyUnit, parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { SubAccount } from "@ledgerhq/types-live";
+import { acceptTransaction } from "./speculos-deviceActions";
+
+const maxAccounts = 5;
+const currency = getCryptoCurrencyById("cardano");
+const minBalanceRequired = parseCurrencyUnit(currency.units[0], "2.2");
+const minBalanceRequiredForMaxSend = parseCurrencyUnit(currency.units[0], "1");
+const minBalanceRequiredForDelegate = parseCurrencyUnit(currency.units[0], "3");
+const minSpendableRequiredForTokenTx = parseCurrencyUnit(currency.units[0], "1");
+
+const cardano: AppSpec<Transaction> = {
+  name: "cardano",
+  currency: getCryptoCurrencyById("cardano"),
+  appQuery: {
+    model: DeviceModelId.nanoSP,
+    appName: "CardanoADA",
+    // FIXME latest (v7) app version requires to update cardano libs
+    appVersion: "6.1.2",
+  },
+  minViableAmount: minBalanceRequired,
+  genericDeviceAction: acceptTransaction,
+  testTimeout: 5 * 60 * 1000,
+  mutations: [
+    {
+      name: "move ~10% token",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gte(minSpendableRequiredForTokenTx), "balance is too low");
+        const sibling = pickSiblings(siblings, maxAccounts);
+        const recipient = sibling.freshAddress;
+        const transaction = bridge.createTransaction(account);
+
+        const subAccount = account.subAccounts?.find(subAccount =>
+          subAccount.balance.gt(1),
+        ) as SubAccount;
+        invariant(subAccount, "No token account with balance");
+
+        const updates = [
+          { subAccountId: subAccount.id },
+          { recipient },
+          {
+            amount: new BigNumber(subAccount.balance.dividedBy(10)).dp(0, BigNumber.ROUND_CEIL),
+          },
+        ];
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({ operation, transaction }): void => {
+        botTest("subOperations is defined", () => expect(operation.subOperations).toBeTruthy());
+
+        botTest("there's only one subOperation", () =>
+          expect(operation.subOperations?.length).toEqual(1),
+        );
+
+        const subOperation = operation.subOperations && operation.subOperations[0];
+
+        botTest("subOperation have correct tx amount", () =>
+          expect(subOperation?.value).toEqual(transaction.amount),
+        );
+      },
+    },
+    {
+      testDestination: genericTestDestination,
+      name: "move ~50%",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minBalanceRequired), "balance is too low");
+        const sibling = pickSiblings(siblings, maxAccounts);
+        const recipient = sibling.freshAddress;
+        const transaction = bridge.createTransaction(account);
+
+        const updates = [
+          { recipient },
+          {
+            amount: new BigNumber(account.balance.dividedBy(2)).dp(0, BigNumber.ROUND_CEIL),
+          },
+          { memo: "LedgerLiveBot" },
+        ];
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({ accountBeforeTransaction, operation, transaction }): void => {
+        const cardanoResources = (accountBeforeTransaction as CardanoAccount)
+          .cardanoResources as CardanoResources;
+
+        const extra: CardanoOperationExtra = {
+          memo: transaction.memo,
+        };
+
+        if (cardanoResources.delegation?.rewards.gt(0)) {
+          extra.rewards = formatCurrencyUnit(
+            accountBeforeTransaction.currency.units[0],
+            new BigNumber(cardanoResources.delegation.rewards),
+            {
+              showCode: true,
+              disableRounding: true,
+            },
+          );
+        }
+
+        botTest("operation extra matches memo", () => expect(operation.extra).toEqual(extra));
+
+        botTest("optimistic value matches transaction amount", () =>
+          expect(transaction.amount).toEqual(operation.value.minus(operation.fee)),
+        );
+      },
+    },
+    {
+      name: "send max",
+      maxRun: 1,
+      testDestination: genericTestDestination,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minBalanceRequiredForMaxSend), "balance is too low");
+        const sibling = pickSiblings(siblings, maxAccounts);
+        const recipient = sibling.freshAddress;
+        const transaction = bridge.createTransaction(account);
+
+        const updates = [{ recipient }, { useAllAmount: true }];
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({ account }): void => {
+        const cardanoResources = (account as CardanoAccount).cardanoResources as CardanoResources;
+        const utxoTokens = cardanoResources.utxos.map(u => u.tokens).flat();
+        const tokenBalance = mergeTokens(utxoTokens);
+        const requiredAdaForTokens = tokenBalance.length
+          ? TyphonUtils.calculateMinUtxoAmount(
+              tokenBalance,
+              new BigNumber(cardanoResources.protocolParams.lovelacePerUtxoWord),
+              false,
+            )
+          : new BigNumber(0);
+
+        botTest("remaining balance equals requiredAdaForTokens)", () =>
+          expect(account.balance).toEqual(requiredAdaForTokens),
+        );
+      },
+    },
+    {
+      name: "delegate to pool",
+      maxRun: 1,
+      transaction: ({ account, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gte(minBalanceRequiredForDelegate), "balance is too low");
+        const transaction = bridge.createTransaction(account);
+        return {
+          transaction,
+          updates: [
+            {
+              mode: "delegate",
+              poolId: "7df262feae9201d1b2e32d4c825ca91b29fbafb2b8e556f6efb7f549",
+            },
+          ],
+        };
+      },
+      test: ({ operation, transaction, accountBeforeTransaction }): void => {
+        botTest("check delegate operation type", () => {
+          expect(operation.type).toEqual("DELEGATE");
+        });
+
+        botTest("check operation value", () => {
+          const cardanoResources = (accountBeforeTransaction as CardanoAccount).cardanoResources;
+          const isStakeKeyRegistered = cardanoResources.delegation?.status ?? false;
+          let opValue = transaction.fees as BigNumber;
+          if (!isStakeKeyRegistered) {
+            opValue = opValue.plus(cardanoResources.protocolParams.stakeKeyDeposit);
+          }
+          expect(operation.value.toString()).toEqual(opValue.toString());
+        });
+      },
+    },
+    {
+      name: "redelegate to pool",
+      maxRun: 1,
+      transaction: ({ account, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gte(minBalanceRequiredForDelegate), "balance is too low");
+        invariant(
+          (account as CardanoAccount).cardanoResources.delegation?.poolId,
+          "account should already be delegated to redelegate",
+        );
+        const transaction = bridge.createTransaction(account);
+        return {
+          transaction,
+          updates: [
+            {
+              mode: "delegate",
+              poolId: "da50099e7aa1d926e1888990b1c404caf554dd6f68a1cb0322999d1d",
+            },
+          ],
+        };
+      },
+      test: ({ operation, transaction }): void => {
+        botTest("check delegate operation type", () => {
+          expect(operation.type).toEqual("DELEGATE");
+        });
+
+        botTest("op value should be equal to fees", () => {
+          expect(operation.value.toString()).toEqual(transaction.fees?.toString());
+        });
+      },
+    },
+    {
+      name: "undelegate",
+      maxRun: 1,
+      transaction: ({ account, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gte(minBalanceRequiredForDelegate), "balance is too low");
+        invariant(
+          (account as CardanoAccount).cardanoResources.delegation?.poolId,
+          "account should already be delegated to undelegate",
+        );
+        const transaction = bridge.createTransaction(account);
+        return {
+          transaction,
+          updates: [
+            {
+              mode: "undelegate",
+            },
+          ],
+        };
+      },
+      test: ({ operation, transaction }): void => {
+        botTest("check undelegate operation type", () => {
+          expect(operation.type).toEqual("UNDELEGATE");
+        });
+
+        botTest("op value should be equal to fees", () => {
+          expect(operation.value.toString()).toEqual(transaction.fees?.toString());
+        });
+      },
+    },
+  ],
+};
+
+export default { cardano };

package/src/speculos-deviceActions.ts

@@ -0,0 +1,132 @@
+import type { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+import type { Transaction } from "./types";
+import { getAccountStakeCredential, getBipPathString } from "./logic";
+import {
+  deviceActionFlow,
+  formatDeviceAmount,
+  SpeculosButton,
+} from "@ledgerhq/coin-framework/bot/specs";
+
+export const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "New ordinary",
+    },
+    {
+      title: "transaction?",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "Warning:",
+      button: SpeculosButton.BOTH,
+      expectedValue: () => "cannot verify network id: no outputs or withrawals",
+    },
+    {
+      title: "Auxiliary data hash",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "Send to address (1/3)",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Send to address (2/3)",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Send to address (3/3)",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "Send to address (1/2)",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Send to address (2/2)",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "Send",
+      button: SpeculosButton.BOTH,
+      ignoreAssertionFailure: true,
+      expectedValue: ({ account, status }) => formatDeviceAmount(account.currency, status.amount),
+    },
+    {
+      title: "Asset fingerprint",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "Token amount",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "Confirm",
+    },
+    {
+      title: "output?",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "Transaction fee",
+      button: SpeculosButton.BOTH,
+      ignoreAssertionFailure: true,
+      expectedValue: ({ account, status }) =>
+        formatDeviceAmount(account.currency, status.estimatedFees),
+    },
+    {
+      title: "Register",
+    },
+    {
+      title: "Deregister",
+    },
+    {
+      title: "stake key",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "Stake key",
+      button: SpeculosButton.BOTH,
+      expectedValue: ({ account }) => {
+        const stakeCred = getAccountStakeCredential(account.xpub as string, account.index);
+        const bipPath = getBipPathString({
+          account: stakeCred.path.account,
+          chain: stakeCred.path.chain,
+          index: stakeCred.path.index,
+        });
+        return `m/${bipPath}`;
+      },
+    },
+    {
+      title: "Transaction TTL",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "...",
+    },
+    {
+      title: "registration?",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "deregistration?",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "Delegate stake (1/2)",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Delegate stake (2/2)",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "delegation?",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "transaction?",
+      final: true,
+      button: SpeculosButton.BOTH,
+    },
+  ],
+});