@ledgerhq/coin-tezos 0.4.0-nightly.0

package/src/datasets/tezos.scanAccounts.1.ts

@@ -0,0 +1,35 @@
+export default {
+  name: "tezos seed 1",
+  unstableAccounts: true,
+  // accounts are staking so receive over time. we disable for now snapshot comparison
+  apdus: `
+    => 800200000d038000002c800006c180000000
+    <= 2102ac76ba226118e2d593d09cd7e395546b7540c0e7fb3eb430da59f7982af632969000
+    => 8002000015058000002c800006c1800000008000000080000001
+    <= 2102b058662fd530e6463d774e3951a40ddd5e430dbeb62673f90caca0cec58735fd9000
+    => 8002000011048000002c800006c18000000080000001
+    <= 2102670e5e92d06e725b68edda589678fdf0f85a582df06ee634d841cf8042db63839000
+    => 8002000015058000002c800006c1800000008000000080000000
+    <= 2102f7ed85c519f7d39a664935a410d1a41ca302dfa3eee228e92cbe0dc12aba7a189000
+    => 8002000015058000002c800006c1800000018000000080000000
+    <= 2102c26d0da1978b7a7596c9853d80d0beac20519c73e76e7f677540db47165d94f39000
+    => 8002000015058000002c800006c1800000028000000080000000
+    <= 21020058c0efd324fa13d778c4b0995f6fa8d9c85e561c1465d770d4011993f557509000
+    => 8002000015058000002c800006c1800000038000000080000000
+    <= 21029bfe70b3e94ff23623f6c42f6e081a9ca8cc78f74b0d8da58f0d4cdc41c33c1a9000
+    => 8002000015058000002c800006c1800000048000000080000000
+    <= 21021d3b9b84feb81d5215cca4f0a016e99fc6cf86d06e864cb4a5098709f16aa2219000
+    => 8002000015058000002c800006c1800000058000000080000000
+    <= 21020162dc75ad3c2b6e097d15a1513033c60d8a033f2312ff5a6ead812228d9d6539000
+    => 8002000015058000002c800006c1800000068000000080000000
+    <= 21021831897c4224296519d496d32fdf9e17fb4af680635c5dbbc46cde84fe11dcc99000
+    => 8002000011048000002c800006c18000000080000000
+    <= 210294e8344ae6df2d3123fa100b5abd40cee339c67838b1c34c4f243cc582f4d2d89000
+    => 8002000011048000002c800006c18000000180000000
+    <= 2102389ffd73423626894cb151416e51c72ec285376673daf83545eb5edb45b261ce9000
+    => 8002000011048000002c800006c18000000280000000
+    <= 2102e4c49994c90ffe2e5480826d2f49fb9d0f45280e20bd0a61c488f652d7af0f9c9000
+    => 8002000011048000002c800006c18000000380000000
+    <= 2102a9ae8b0ff5f9a43565793ad78e10db6f12177d904d208ada591b8a5b9999e3fd9000
+    `,
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+
+export { createBridges } from "./bridge/index";

package/src/signer/getAddress.ts

@@ -0,0 +1,13 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import type { TezosSigner } from "../types";
+
+const getAddress = (signerContext: SignerContext<TezosSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const r = await signerContext(deviceId, signer => signer.getAddress(path, { verify }));
+    return { ...r, path };
+  };
+};
+
+export default getAddress;

package/src/signer/index.ts

@@ -0,0 +1,7 @@
+/**
+ * This directory is the home for all types and logic based on Ledgers signer.
+ */
+
+import getAddress from "./getAddress";
+
+export default getAddress;

package/src/test/bot-deviceActions.ts

@@ -0,0 +1,79 @@
+import type { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+import type { Transaction } from "../types";
+import {
+  deviceActionFlow,
+  formatDeviceAmount,
+  SpeculosButton,
+} from "@ledgerhq/coin-framework/bot/specs";
+
+export const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Review",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Withdraw",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Custom Delegate",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      // device sometimes know the text of a given delegator, we're not validating the actual text
+      title: "Delegate",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Delegate Name",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Confirm",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => {
+        return transaction.mode === "send" ? "Transaction" : "Delegation";
+      },
+    },
+    {
+      title: "Amount",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, transaction }) =>
+        formatDeviceAmount(account.currency, transaction.amount, {
+          postfixCode: true,
+        }),
+    },
+    {
+      title: "Fee",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, status }) =>
+        formatDeviceAmount(account.currency, status.estimatedFees, {
+          postfixCode: true,
+        }),
+    },
+    {
+      title: "Source",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account }) => account.freshAddress,
+    },
+    {
+      title: "Destination",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => transaction.recipient,
+    },
+    {
+      title: "Storage Limit",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => transaction.storageLimit?.toString() || "",
+    },
+    {
+      title: "Reject",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Accept",
+      button: SpeculosButton.BOTH,
+    },
+  ],
+});

package/src/test/bot-specs.ts

@@ -0,0 +1,152 @@
+import sample from "lodash/sample";
+import invariant from "invariant";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { genericTestDestination, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+import type { AppSpec } from "@ledgerhq/coin-framework/bot/types";
+import { DeviceModelId } from "@ledgerhq/devices";
+import { isTezosAccount, type Transaction } from "../types";
+import { getAccountDelegationSync, isAccountDelegating } from "../api/bakers";
+import whitelist from "../api/bakers.whitelist-default";
+import { acceptTransaction } from "./bot-deviceActions";
+import { Account } from "@ledgerhq/types-live";
+
+const maxAccount = 12;
+
+function expectUnrevealed(account: Account) {
+  if (!isTezosAccount(account)) throw Error("Not TezosAccount type");
+  invariant(account.tezosResources?.revealed === false, "account must be unreleaved");
+}
+function expectRevealed(account: Account) {
+  if (!isTezosAccount(account)) throw Error("Not TezosAccount type");
+  invariant(account.tezosResources?.revealed === true, "account must be releaved");
+}
+
+const tezosUnit = getCryptoCurrencyById("tezos").units[0];
+
+const safeMinimumForDestinationNotCreated = parseCurrencyUnit(tezosUnit, "0.6");
+const strictMin = parseCurrencyUnit(tezosUnit, "0.02");
+
+const tezos: AppSpec<Transaction> = {
+  name: "Tezos",
+  currency: getCryptoCurrencyById("tezos"),
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "TezosWallet",
+  },
+  genericDeviceAction: acceptTransaction,
+  testTimeout: 2 * 60 * 1000,
+  minViableAmount: strictMin,
+  transactionCheck: ({ maxSpendable }) => {
+    invariant(maxSpendable.gt(strictMin), "balance is too low");
+  },
+  mutations: [
+    {
+      name: "send unrevealed",
+      maxRun: 1,
+      testDestination: genericTestDestination,
+      transaction: ({ maxSpendable, account, siblings, bridge }) => {
+        expectUnrevealed(account);
+        const sibling = pickSiblings(siblings, maxAccount);
+        const recipient = sibling.freshAddress;
+        const amount = maxSpendable.div(2).integerValue();
+        if (sibling.balance.eq(0) && amount.lt(safeMinimumForDestinationNotCreated)) {
+          throw new Error("need more funds to send to new address");
+        }
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [{ recipient, amount }],
+        };
+      },
+    },
+    {
+      name: "send revealed",
+      maxRun: 2,
+      testDestination: genericTestDestination,
+      transaction: ({ maxSpendable, account, siblings, bridge }) => {
+        expectRevealed(account);
+        const sibling = pickSiblings(siblings, maxAccount);
+        const recipient = sibling.freshAddress;
+        const amount = maxSpendable.div(2).integerValue();
+        if (sibling.balance.eq(0) && amount.lt(safeMinimumForDestinationNotCreated)) {
+          throw new Error("need more funds to send to new address");
+        }
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [{ recipient, amount }],
+        };
+      },
+    },
+    {
+      name: "send max (non delegating)",
+      maxRun: 3,
+      testDestination: genericTestDestination,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(!isAccountDelegating(account), "account must not be delegating");
+        const sibling = pickSiblings(siblings, maxAccount);
+        const recipient = sibling.freshAddress;
+        if (sibling.balance.eq(0) && maxSpendable.lt(safeMinimumForDestinationNotCreated)) {
+          throw new Error("need more funds to send to new address");
+        }
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [{ recipient, useAllAmount: true }],
+        };
+      },
+    },
+    {
+      name: "delegate unrevealed",
+      maxRun: 1,
+      transaction: ({ account, bridge }) => {
+        expectUnrevealed(account);
+        const d = getAccountDelegationSync(account);
+        const recipient = sample(d ? whitelist.filter(w => w !== d.address) : whitelist);
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [{ recipient, mode: "delegate" }],
+        };
+      },
+    },
+    {
+      name: "delegate revealed",
+      maxRun: 1,
+      transaction: ({ account, bridge }) => {
+        expectRevealed(account);
+        const d = getAccountDelegationSync(account);
+        const recipient = sample(d ? whitelist.filter(w => w !== d.address) : whitelist);
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [{ recipient, mode: "delegate" }],
+        };
+      },
+    },
+    {
+      name: "undelegate unrevealed",
+      maxRun: 1,
+      transaction: ({ account, bridge }) => {
+        invariant(getAccountDelegationSync(account), "account must be delegating");
+        expectUnrevealed(account);
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [{ mode: "undelegate" }],
+        };
+      },
+    },
+    {
+      name: "undelegate revealed",
+      maxRun: 1,
+      transaction: ({ account, bridge }) => {
+        invariant(getAccountDelegationSync(account), "account must be delegating");
+        expectRevealed(account);
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [{ mode: "undelegate" }],
+        };
+      },
+    },
+  ],
+};
+
+export default {
+  tezos,
+};

package/src/test/bridgeDatasetTest.ts

@@ -0,0 +1,132 @@
+import { AmountRequired, NotEnoughBalance } from "@ledgerhq/errors";
+import type { DatasetTest, DerivationMode } from "@ledgerhq/types-live";
+import type { TezosAccountRaw, Transaction } from "../types";
+import tezosScanAccounts1 from "../datasets/tezos.scanAccounts.1";
+
+function makeAccountRaw(
+  name: string,
+  pubkey: string,
+  address: string,
+  derivationMode: DerivationMode,
+): TezosAccountRaw {
+  return {
+    id: `js:2:tezos:${pubkey}:${derivationMode}`,
+    seedIdentifier: address,
+    name: "Tezos " + name,
+    derivationMode,
+    index: 0,
+    freshAddress: address,
+    freshAddressPath: "",
+    blockHeight: 0,
+    operations: [],
+    pendingOperations: [],
+    currencyId: "tezos",
+    lastSyncDate: "",
+    balance: "0",
+    xpub: pubkey,
+    subAccounts: [],
+    tezosResources: { revealed: true, counter: 0 },
+  };
+}
+
+export const accountTZrevealedDelegating = makeAccountRaw(
+  "TZrevealedDelegating",
+  "02389ffd73423626894cb151416e51c72ec285376673daf83545eb5edb45b261ce",
+  "tz1boBHAVpwcvKkNFAQHYr7mjxAz1PpVgKq7",
+  "tezbox",
+);
+
+const accountTZnew = makeAccountRaw(
+  "TZnew",
+  "02a9ae8b0ff5f9a43565793ad78e10db6f12177d904d208ada591b8a5b9999e3fd",
+  "tz1VSichevvJSNkSSntgwKDKikWNB6iqNJii",
+  "tezbox",
+);
+
+const accountTZnotRevealed = makeAccountRaw(
+  "TZnotRevealed",
+  "020162dc75ad3c2b6e097d15a1513033c60d8a033f2312ff5a6ead812228d9d653",
+  "tz1PWFt4Ym6HedY78MgUP2kVDtSampGwprs5",
+  "tezosbip44h",
+);
+
+const accountTZRevealedNoDelegate = makeAccountRaw(
+  "TZRevealedNoDelegate",
+  "029bfe70b3e94ff23623f6c42f6e081a9ca8cc78f74b0d8da58f0d4cdc41c33c1a",
+  "tz1YkAjh5mm5gJ5u3VbFLEtpAG7cFo7PfCux",
+  "tezosbip44h",
+);
+
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    tezos: {
+      FIXME_ignoreOperationFields: ["blockHeight"],
+      scanAccounts: [tezosScanAccounts1],
+      accounts: [
+        {
+          raw: accountTZrevealedDelegating,
+          transactions: [
+            {
+              name: "No amount",
+              transaction: t => ({
+                ...t,
+                recipient: "tz1VSichevvJSNkSSntgwKDKikWNB6iqNJii",
+              }),
+              expectedStatus: {
+                errors: { amount: new AmountRequired() },
+                warnings: {},
+              },
+            },
+          ],
+        },
+        {
+          raw: accountTZRevealedNoDelegate,
+          transactions: [],
+        },
+        {
+          raw: accountTZnotRevealed,
+          transactions: [
+            {
+              name: "send more than min allowed",
+              transaction: (t, account) => ({
+                ...t,
+                amount: account.balance.minus("100"),
+                recipient: "tz1VSichevvJSNkSSntgwKDKikWNB6iqNJii",
+              }),
+              expectedStatus: {
+                errors: {
+                  amount: new NotEnoughBalance(),
+                },
+                warnings: {},
+              },
+            },
+            /* // FIXME broken test
+            {
+              name: "Amount > spendablebalance",
+              transaction: (t, account) => ({
+                ...t,
+                amount: account.balance,
+                recipient: accountTZnew.freshAddress,
+              }),
+              expectedStatus: {
+                errors: {
+                  amount: new NotEnoughBalance(),
+                },
+                warnings: {},
+              },
+            },
+            */
+          ],
+        },
+        {
+          raw: accountTZnew,
+          test: (expect, account) => {
+            expect(account.operations).toEqual([]);
+          },
+          transactions: [],
+        },
+      ],
+    },
+  },
+};

package/src/test/cli.ts

@@ -0,0 +1,137 @@
+import { from, Observable } from "rxjs";
+import { map } from "rxjs/operators";
+import invariant from "invariant";
+import { BigNumber } from "bignumber.js";
+import flatMap from "lodash/flatMap";
+import type { Account, AccountLike, AccountLikeArray, SubAccount } from "@ledgerhq/types-live";
+import type { Transaction, Baker } from "../types";
+import { listBakers, fetchAllBakers } from "../api/bakers";
+import defaultList from "../api/bakers.whitelist-default";
+
+const options = [
+  {
+    name: "mode",
+    type: String,
+    desc: "mode of transaction",
+  },
+  {
+    name: "storageLimit",
+    type: String,
+    desc: "how much storageLimit. default is estimated with the recipient",
+  },
+  {
+    name: "subAccount",
+    type: String,
+    desc: "use a sub account instead of the parent by index",
+    multiple: true,
+  },
+  {
+    name: "fees",
+    type: String,
+    desc: "how much fees",
+  },
+  {
+    name: "gasLimit",
+    type: String,
+    desc: "how much gasLimit. default is estimated with the recipient",
+  },
+];
+
+function inferAccounts(account: Account, opts: Record<string, any>): AccountLikeArray {
+  invariant(account.currency.family === "tezos", "tezos family");
+
+  if (!opts.subAccount) {
+    const accounts: Account[] = [account];
+    return accounts;
+  }
+
+  const { subAccounts } = account;
+  invariant(subAccounts, "no sub accounts");
+  return opts.subAccount.map((i: number) => {
+    const acc = (subAccounts as SubAccount[])[i];
+    invariant(acc, "sub account not found (index %s)", i);
+    return acc;
+  });
+}
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+  }>,
+  opts: Record<string, any>,
+  { inferAmount }: any,
+): Transaction[] {
+  return flatMap(transactions, ({ transaction, account }) => {
+    invariant(transaction.family === "tezos", "tezos family");
+    let subAccountId;
+
+    return {
+      ...transaction,
+      mode: opts.mode || "send",
+      subAccountId,
+      fees: opts.fees ? inferAmount(account, opts.fees) : null,
+      gasLimit: opts.gasLimit ? new BigNumber(opts.gasLimit) : null,
+      storageLimit: opts.storageLimit ? new BigNumber(opts.storageLimit) : null,
+    };
+  });
+}
+
+const bakersFormatters = {
+  json: (list: Baker[]) => JSON.stringify(list),
+  default: (list: Baker[]) =>
+    list
+      .map(b => `${b.address} "${b.name}" ${b.nominalYield} ${b.capacityStatus} ${b.logoURL}`)
+      .join("\n"),
+};
+const tezosListBakers = {
+  args: [
+    {
+      name: "whitelist",
+      desc: "filter whitelist",
+      type: Boolean,
+    },
+    {
+      name: "format",
+      desc: Object.keys(bakersFormatters).join(" | "),
+      type: String,
+    },
+  ],
+  job: ({
+    whitelist,
+    format,
+  }: Partial<{
+    whitelist: boolean;
+    format: "json" | "default";
+  }>): Observable<string> =>
+    from(whitelist ? listBakers(defaultList) : fetchAllBakers()).pipe(
+      map((list: Baker[]) => {
+        const f = (format && bakersFormatters[format]) || bakersFormatters.default;
+        return f(list);
+      }),
+    ),
+};
+
+export type CliTools = {
+  options: typeof options;
+  inferTransactions: (
+    transactions: Array<{
+      account: AccountLike;
+      transaction: Transaction;
+    }>,
+    opts: Record<string, any>,
+    { inferAmount }: any,
+  ) => Transaction[];
+  commands: { tezosListBakers: typeof tezosListBakers };
+};
+
+export default function makeCliTools() {
+  return {
+    options,
+    inferAccounts,
+    inferTransactions,
+    commands: {
+      tezosListBakers,
+    },
+  };
+}

package/src/test/index.ts

@@ -0,0 +1 @@
+export * from "./bridgeDatasetTest";

package/src/types/errors.ts

@@ -0,0 +1,5 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const InvalidAddressBecauseAlreadyDelegated = createCustomErrorClass(
+  "InvalidAddressBecauseAlreadyDelegated",
+);

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from "./errors";
+export * from "./model";
+export * from "./signer";

package/src/types/model.fixture.ts

@@ -0,0 +1,89 @@
+import BigNumber from "bignumber.js";
+import { faker } from "@faker-js/faker";
+import type {
+  TezosAccount,
+  TezosOperation,
+  TezosOperationExtra,
+  TezosResources,
+  Transaction,
+} from "./model";
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets/abandonseed";
+import { listCryptoCurrencies } from "@ledgerhq/cryptoassets/currencies";
+import { emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
+
+const currency = listCryptoCurrencies(true).find(c => c.id === "tezos")!;
+
+export function createFixtureAccount(account?: Partial<TezosAccount>): TezosAccount {
+  const tezosResources: TezosResources = account?.tezosResources || {
+    revealed: account?.tezosResources?.revealed || true,
+    counter: account?.tezosResources?.counter || faker.number.int(),
+  };
+
+  const freshAddress = {
+    // Value coming from taquito.io documentation
+    address: "tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb",
+    derivationPath: "derivation_path",
+  };
+
+  return {
+    type: "Account",
+    id: faker.string.uuid(),
+    seedIdentifier: faker.string.uuid(),
+    derivationMode: "",
+    index: faker.number.int(),
+    freshAddress: account?.freshAddress || freshAddress.address,
+    freshAddressPath: freshAddress.derivationPath,
+    used: true,
+    balance: account?.balance || new BigNumber(0),
+    spendableBalance: account?.spendableBalance || new BigNumber(0),
+    creationDate: faker.date.past(),
+    blockHeight: faker.number.int({ min: 100_000, max: 200_000 }),
+    currency,
+    operationsCount: account?.operationsCount || 0,
+    operations: account?.operations || [],
+    pendingOperations: account?.pendingOperations || [],
+    lastSyncDate: new Date(),
+    balanceHistoryCache: emptyHistoryCache,
+    swapHistory: [],
+
+    tezosResources,
+  };
+}
+
+export function createFixtureTransaction(tx?: Partial<Transaction>): Transaction {
+  return {
+    amount: tx?.amount || new BigNumber(0),
+    recipient: tx?.recipient || getAbandonSeedAddress("tezos"),
+
+    family: "tezos",
+    mode: tx?.mode || "send",
+    networkInfo: tx?.networkInfo || undefined,
+    fees: tx?.fees || undefined,
+    gasLimit: tx?.gasLimit || undefined,
+    storageLimit: tx?.storageLimit || undefined,
+    estimatedFees: tx?.estimatedFees || undefined,
+    taquitoError: tx?.taquitoError || undefined,
+  };
+}
+
+export function createFixtureOperation(operation?: Partial<TezosOperation>): TezosOperation {
+  const extra: TezosOperationExtra = {
+    id: operation?.extra?.id || 0,
+  };
+
+  return {
+    id: operation?.id || faker.string.uuid(),
+    hash: operation?.hash || faker.string.uuid(),
+    type: operation?.type || "ACTIVATE",
+    value: operation?.value || new BigNumber(faker.string.numeric()),
+    fee: operation?.fee || new BigNumber(0),
+    // senders & recipients addresses
+    senders: operation?.senders || [],
+    recipients: operation?.recipients || [],
+    blockHeight: operation?.blockHeight || undefined,
+    blockHash: operation?.blockHash || undefined,
+    accountId: operation?.accountId || faker.string.uuid(),
+    date: operation?.date || faker.date.past(),
+    extra,
+  };
+}