@ledgerhq/coin-tezos 0.4.0-nightly.0

package/src/bridge/serialization.ts

@@ -0,0 +1,27 @@
+import type { TezosAccount, TezosAccountRaw, TezosResources, TezosResourcesRaw } from "../types";
+import { Account, AccountRaw } from "@ledgerhq/types-live";
+
+export function toTezosResourcesRaw(r: TezosResources): TezosResourcesRaw {
+  const { revealed, counter } = r;
+  return { revealed, counter };
+}
+
+export function fromTezosResourcesRaw(r: TezosResourcesRaw): TezosResources {
+  const { revealed, counter } = r;
+  return { revealed, counter };
+}
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw) {
+  const tezosAccount = account as TezosAccount;
+  if (tezosAccount.tezosResources) {
+    (accountRaw as TezosAccountRaw).tezosResources = toTezosResourcesRaw(
+      tezosAccount.tezosResources,
+    );
+  }
+}
+
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
+  const tezosResourcesRaw = (accountRaw as TezosAccountRaw).tezosResources;
+  if (tezosResourcesRaw)
+    (account as TezosAccount).tezosResources = fromTezosResourcesRaw(tezosResourcesRaw);
+}

package/src/bridge/signOperation.test.ts

@@ -0,0 +1,211 @@
+import BigNumber from "bignumber.js";
+import { OpKind, TezosToolkit } from "@taquito/taquito";
+import { SignOperationEvent } from "@ledgerhq/types-live";
+import buildSignOperation, { getOperationContents } from "./signOperation";
+import { TezosSigner } from "../types";
+import { createFixtureAccount, createFixtureTransaction } from "../types/model.fixture";
+
+const mockForgeOperations = jest.fn().mockResolvedValue("FORGED_OP");
+jest.mock("@taquito/taquito", () => ({
+  ...jest.requireActual("@taquito/taquito"),
+  TezosToolkit: jest.fn().mockReturnValue({
+    setProvider: jest.fn(),
+    rpc: {
+      getBlock: jest.fn().mockResolvedValue({ hash: "hash" }),
+      getContract: jest.fn().mockResolvedValue({ counter: "12" }),
+      forgeOperations: () => mockForgeOperations(),
+    },
+  }),
+}));
+
+describe("signOperation", () => {
+  const mockSign = jest.fn().mockResolvedValue({
+    bytes: "SIG_BYTES",
+    sig: "SIG",
+    prefixSig: "PREFIX_SIG",
+    sbytes: "03SBYTES",
+  });
+  const fakeSigner = {
+    getAddress: jest.fn(),
+    signOperation: jest.fn(),
+    createLedgerSigner: () => ({
+      publicKey: () => Promise.resolve("PUBKEY"),
+      publicKeyHash: () => Promise.resolve("PUBKEYHASH"),
+      sign: () => mockSign(),
+      secretKey: () => Promise.resolve(undefined),
+    }),
+  };
+  const signerContext = <T>(_deviceId: string, fn: (signer: TezosSigner) => Promise<T>) =>
+    fn(fakeSigner);
+  const signOperation = buildSignOperation(signerContext);
+  const deviceId = "dummyDeviceId";
+
+  afterEach(() => {
+    mockForgeOperations.mockClear();
+    mockSign.mockClear();
+  });
+
+  it("returns events in the right order", done => {
+    // GIVEN
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction({ fees: BigNumber(0) });
+
+    // WHEN & THEN
+    const expectedEvent = [
+      {
+        type: "device-signature-requested",
+      },
+      {
+        type: "device-signature-granted",
+      },
+      {
+        type: "signed",
+      },
+    ];
+    let eventIdx = 0;
+    signOperation({ account, deviceId, transaction }).forEach(e => {
+      try {
+        expect(e.type).toEqual(expectedEvent[eventIdx].type);
+        eventIdx++;
+
+        if (eventIdx === expectedEvent.length) {
+          done();
+        }
+      } catch (err) {
+        done(err);
+      }
+    });
+  });
+
+  it("returns signature value from LedgerSigner", done => {
+    // GIVEN
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction({ fees: new BigNumber(0) });
+
+    // WHEN & THEN
+    const subscriber = signOperation({ account, deviceId, transaction }).subscribe(
+      (e: SignOperationEvent) => {
+        if (e.type === "signed") {
+          const signature = e.signedOperation.signature;
+          expect(signature).toEqual("SBYTES");
+          expect(mockSign).toHaveBeenCalledTimes(1);
+          expect(mockForgeOperations).toHaveBeenCalledTimes(1);
+
+          // Cleanup
+          subscriber.unsubscribe();
+          done();
+        }
+      },
+    );
+  });
+});
+
+describe("getOperationContents - revealed account", () => {
+  const tezos = new TezosToolkit("MOCK_API_KEY");
+  const account = createFixtureAccount({ freshAddress: "tz1addr" });
+
+  it("mode - send", async () => {
+    const transaction = createFixtureTransaction({
+      family: "tezos",
+      amount: new BigNumber(0),
+      recipient: "RECIPIENT_ADD",
+      fees: new BigNumber(0),
+      mode: "send",
+      gasLimit: new BigNumber(0),
+      storageLimit: new BigNumber(0),
+    });
+
+    const { type, contents } = await getOperationContents({
+      account,
+      transaction,
+      tezos,
+      counter: 0,
+      public_key: "pk",
+      public_key_hash: "pkh",
+    });
+
+    expect(type).toBe("OUT");
+    expect(contents.length).toEqual(1);
+    expect(contents).toStrictEqual([
+      {
+        kind: OpKind.TRANSACTION,
+        amount: transaction.amount.toString(),
+        destination: transaction.recipient,
+        source: "tz1addr",
+        counter: "1",
+        fee: new BigNumber(0).toString(),
+        gas_limit: new BigNumber(0).toString(),
+        storage_limit: new BigNumber(0).toString(),
+      },
+    ]);
+  });
+
+  it("mode - delegate", async () => {
+    const transaction = createFixtureTransaction({
+      family: "tezos",
+      amount: new BigNumber(0),
+      recipient: "RECIPIENT_ADD",
+      fees: new BigNumber(0),
+      mode: "delegate",
+      gasLimit: new BigNumber(0),
+      storageLimit: new BigNumber(0),
+    });
+
+    const { type, contents } = await getOperationContents({
+      account,
+      transaction,
+      tezos,
+      counter: 0,
+      public_key: "pk",
+      public_key_hash: "pkh",
+    });
+
+    expect(type).toBe("DELEGATE");
+    expect(contents.length).toEqual(1);
+    expect(contents).toStrictEqual([
+      {
+        kind: OpKind.DELEGATION,
+        source: "tz1addr",
+        counter: "1",
+        fee: new BigNumber(0).toString(),
+        gas_limit: new BigNumber(0).toString(),
+        storage_limit: new BigNumber(0).toString(),
+        delegate: transaction.recipient,
+      },
+    ]);
+  });
+
+  it("mode - undelegate", async () => {
+    const transaction = createFixtureTransaction({
+      family: "tezos",
+      amount: new BigNumber(0),
+      recipient: "",
+      fees: new BigNumber(0),
+      mode: "undelegate",
+      gasLimit: new BigNumber(0),
+      storageLimit: new BigNumber(0),
+    });
+
+    const { type, contents } = await getOperationContents({
+      account,
+      transaction,
+      tezos,
+      counter: 0,
+      public_key: "pk",
+      public_key_hash: "pkh",
+    });
+
+    expect(type).toBe("UNDELEGATE");
+    expect(contents.length).toEqual(1);
+    expect(contents).toStrictEqual([
+      {
+        kind: OpKind.DELEGATION,
+        source: "tz1addr",
+        counter: "1",
+        fee: new BigNumber(0).toString(),
+        gas_limit: new BigNumber(0).toString(),
+        storage_limit: new BigNumber(0).toString(),
+      },
+    ]);
+  });
+});

package/src/bridge/signOperation.ts

@@ -0,0 +1,213 @@
+import { Observable } from "rxjs";
+import { DEFAULT_FEE, OpKind, TezosToolkit } from "@taquito/taquito";
+import { type OperationContents } from "@taquito/rpc";
+import type {
+  OperationType,
+  SignOperationEvent,
+  SignOperationFnSignature,
+} from "@ledgerhq/types-live";
+import { getEnv } from "@ledgerhq/live-env";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import type { TezosAccount, TezosOperation, TezosSigner, Transaction } from "../types";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+
+export async function getOperationContents({
+  account,
+  transaction,
+  tezos,
+  counter,
+  public_key,
+  public_key_hash,
+}: {
+  account: TezosAccount;
+  transaction: Transaction;
+  tezos: TezosToolkit;
+  counter: number;
+  public_key: string;
+  public_key_hash: string;
+}) {
+  let type: OperationType = "NONE";
+  const { freshAddress } = account;
+
+  const transactionFees = {
+    fee: (transaction.fees || 0).toString(),
+    gas_limit: (transaction.gasLimit || 0).toString(),
+    storage_limit: (transaction.storageLimit || 0).toString(),
+  };
+
+  const contents: OperationContents[] = [];
+
+  if (!account.tezosResources.revealed) {
+    const revealFees = await tezos.estimate.reveal();
+
+    contents.push({
+      kind: OpKind.REVEAL,
+      fee: DEFAULT_FEE.REVEAL.toString(),
+      gas_limit: (revealFees?.gasLimit || 0).toString(),
+      storage_limit: (revealFees?.storageLimit || 0).toString(),
+      source: public_key_hash,
+      counter: (counter + 1).toString(),
+      public_key,
+    });
+  }
+
+  switch (transaction.mode) {
+    case "send": {
+      type = "OUT";
+
+      contents.push({
+        kind: OpKind.TRANSACTION,
+        amount: transaction.amount.toString(),
+        destination: transaction.recipient,
+        source: freshAddress,
+        counter: (counter + 1 + contents.length).toString(),
+        ...transactionFees,
+      });
+
+      break;
+    }
+    case "delegate": {
+      type = "DELEGATE";
+
+      contents.push({
+        kind: OpKind.DELEGATION,
+        source: freshAddress,
+        counter: (counter + 1 + contents.length).toString(),
+        delegate: transaction.recipient,
+        ...transactionFees,
+      });
+
+      break;
+    }
+    case "undelegate": {
+      type = "UNDELEGATE";
+
+      // we undelegate as there's no "delegate" field
+      // OpKind is still "DELEGATION"
+      contents.push({
+        kind: OpKind.DELEGATION,
+        source: freshAddress,
+        counter: (counter + 1 + contents.length).toString(),
+        ...transactionFees,
+      });
+
+      break;
+    }
+    default:
+      throw new Error("not supported");
+  }
+
+  return { type, contents };
+}
+
+const buildSignOperation =
+  (signerContext: SignerContext<TezosSigner>): SignOperationFnSignature<Transaction> =>
+  ({ account, deviceId, transaction }): Observable<SignOperationEvent> =>
+    new Observable(o => {
+      let cancelled = false;
+
+      async function main() {
+        const { fees } = transaction;
+        if (!fees) throw new FeeNotLoaded();
+
+        const { freshAddressPath, freshAddress } = account;
+
+        const tezos = new TezosToolkit(getEnv("API_TEZOS_NODE"));
+
+        const signedInfo = await signerContext(deviceId, async signer => {
+          const ledgerSigner = signer.createLedgerSigner(freshAddressPath, false, 0);
+
+          tezos.setProvider({ signer: ledgerSigner });
+
+          const publicKey = await ledgerSigner.publicKey();
+          const publicKeyHash = await ledgerSigner.publicKeyHash();
+
+          const { rpc } = tezos;
+          const block = await rpc.getBlock();
+          const sourceData = await rpc.getContract(freshAddress);
+
+          o.next({ type: "device-signature-requested" });
+
+          if (cancelled) {
+            return;
+          }
+
+          const { type, contents } = await getOperationContents({
+            account: account as TezosAccount,
+            transaction,
+            tezos,
+            counter: Number(sourceData.counter),
+            public_key: publicKey,
+            public_key_hash: publicKeyHash,
+          });
+
+          const forgedBytes = await rpc.forgeOperations({
+            branch: block.hash,
+            contents,
+          });
+
+          // 0x03 is a conventional prefix (aka a watermark) for tezos transactions
+          const signature = await ledgerSigner.sign(
+            Buffer.concat([Buffer.from("03", "hex"), Buffer.from(forgedBytes, "hex")]).toString(
+              "hex",
+            ),
+          );
+
+          return {
+            type,
+            signature,
+          };
+        });
+
+        if (!signedInfo) {
+          return;
+        }
+        const { type, signature } = signedInfo;
+
+        o.next({ type: "device-signature-granted" });
+
+        // build optimistic operation
+        const txHash = ""; // resolved at broadcast time
+        const senders = [freshAddress];
+        const recipients = [transaction.recipient];
+        const accountId = account.id;
+
+        // currently, all mode are always at least one OUT tx on ETH parent
+        const operation: TezosOperation = {
+          id: encodeOperationId(accountId, txHash, type),
+          hash: txHash,
+          type,
+          value: transaction.amount,
+          fee: fees,
+          extra: {},
+          blockHash: null,
+          blockHeight: null,
+          senders,
+          recipients,
+          accountId,
+          date: new Date(),
+        };
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            // we slice the signature to remove the `03` prefix
+            // which souldn't be included in the signature
+            signature: signature.sbytes.slice(2),
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+
+      return () => {
+        cancelled = true;
+      };
+    });
+
+export default buildSignOperation;

package/src/bridge/transaction.ts

@@ -0,0 +1,94 @@
+import { BigNumber } from "bignumber.js";
+import type { Transaction, TransactionRaw } from "../types";
+import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/serialization";
+import type { Account } from "@ledgerhq/types-live";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+
+export const formatTransaction = (
+  {
+    mode,
+    subAccountId,
+    amount,
+    recipient,
+    gasLimit,
+    storageLimit,
+    fees,
+    useAllAmount,
+    estimatedFees,
+  }: Transaction,
+  mainAccount: Account,
+): string => {
+  const account =
+    (subAccountId && (mainAccount.subAccounts || []).find(a => a.id === subAccountId)) ||
+    mainAccount;
+  return `
+${mode.toUpperCase()} ${
+    useAllAmount
+      ? "MAX"
+      : formatCurrencyUnit(getAccountCurrency(account).units[0], amount, {
+          showCode: true,
+          disableRounding: true,
+        })
+  }
+TO ${recipient}
+with fees=${!fees ? "?" : formatCurrencyUnit(mainAccount.currency.units[0], fees)}
+with gasLimit=${!gasLimit ? "?" : gasLimit.toString()}
+with storageLimit=${!storageLimit ? "?" : storageLimit.toString()}
+(estimatedFees ${
+    !estimatedFees ? "?" : formatCurrencyUnit(mainAccount.currency.units[0], estimatedFees)
+  })`;
+};
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  const { networkInfo } = tr;
+  return {
+    ...common,
+    family: tr.family,
+    mode: tr.mode,
+    networkInfo: networkInfo && {
+      family: networkInfo.family,
+      fees: new BigNumber(networkInfo.fees),
+    },
+    fees: tr.fees ? new BigNumber(tr.fees) : null,
+    gasLimit: tr.gasLimit ? new BigNumber(tr.gasLimit) : null,
+    storageLimit: tr.storageLimit ? new BigNumber(tr.storageLimit) : null,
+    estimatedFees: tr.estimatedFees ? new BigNumber(tr.estimatedFees) : null,
+    taquitoError: tr.taquitoError,
+  };
+};
+
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  const { networkInfo } = t;
+  return {
+    ...common,
+    family: t.family,
+    mode: t.mode,
+    networkInfo: networkInfo && {
+      family: networkInfo.family,
+      fees: networkInfo.fees.toString(),
+    },
+    fees: t.fees ? t.fees.toString() : null,
+    gasLimit: t.gasLimit ? t.gasLimit.toString() : null,
+    storageLimit: t.storageLimit ? t.storageLimit.toString() : null,
+    estimatedFees: t.estimatedFees ? t.estimatedFees.toString() : null,
+    taquitoError: t.taquitoError,
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};

package/src/bridge/transactionStatus.ts

@@ -0,0 +1,130 @@
+import BigNumber from "bignumber.js";
+import {
+  AmountRequired,
+  FeeTooHigh,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  NotEnoughBalanceBecauseDestinationNotCreated,
+  NotEnoughBalanceToDelegate,
+  RecommendUndelegation,
+} from "@ledgerhq/errors";
+import { log } from "@ledgerhq/logs";
+import { TezosAccount, Transaction, TransactionStatus } from "../types";
+import { InvalidAddressBecauseAlreadyDelegated } from "../types/errors";
+import api from "../api/tzkt";
+import { isAccountDelegating } from "../api/bakers";
+import { validateRecipient } from "./prepareTransaction";
+
+const EXISTENTIAL_DEPOSIT = new BigNumber(275000);
+
+export const getTransactionStatus = async (
+  account: TezosAccount,
+  t: Transaction,
+): Promise<TransactionStatus> => {
+  const errors: {
+    recipient?: Error;
+    amount?: Error;
+    fees?: Error;
+  } = {};
+
+  const warnings: {
+    amount?: Error;
+    feeTooHigh?: Error;
+    recipient?: Error;
+  } = {};
+  let resetTotalSpent = false;
+
+  // Recipient validation logic
+  if (t.mode !== "undelegate") {
+    if (account.freshAddress === t.recipient) {
+      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+    } else {
+      const { recipientError, recipientWarning } = await validateRecipient(
+        account.currency,
+        t.recipient,
+      );
+      if (recipientError) {
+        errors.recipient = recipientError;
+      }
+      if (recipientWarning) {
+        warnings.recipient = recipientWarning;
+      }
+    }
+  }
+
+  // Pre validation of amount field
+  const estimatedFees = t.estimatedFees || new BigNumber(0);
+  if (t.mode === "send") {
+    if (!errors.amount && t.amount.eq(0) && !t.useAllAmount) {
+      resetTotalSpent = true;
+      errors.amount = new AmountRequired();
+    } else if (t.amount.gt(0) && estimatedFees.times(10).gt(t.amount)) {
+      warnings.feeTooHigh = new FeeTooHigh();
+    }
+    const thresholdWarning = 0.5 * 10 ** account.currency.units[0].magnitude;
+    if (
+      !errors.amount &&
+      account.balance.minus(t.amount).minus(estimatedFees).lt(thresholdWarning)
+    ) {
+      if (isAccountDelegating(account)) {
+        if (t.useAllAmount) {
+          errors.amount = new RecommendUndelegation();
+        } else {
+          warnings.amount = new RecommendUndelegation();
+        }
+      }
+    }
+  }
+
+  // effective amount
+  // if we also have taquitoError, we interprete them and they override the previously inferred errors
+  if (t.taquitoError) {
+    log("taquitoerror", String(t.taquitoError));
+
+    // remap taquito errors
+    if (
+      t.taquitoError.endsWith("balance_too_low") ||
+      t.taquitoError.endsWith("subtraction_underflow")
+    ) {
+      if (t.mode === "send") {
+        resetTotalSpent = true;
+        errors.amount = new NotEnoughBalance();
+      } else {
+        errors.amount = new NotEnoughBalanceToDelegate();
+      }
+    } else if (t.taquitoError.endsWith("delegate.unchanged")) {
+      errors.recipient = new InvalidAddressBecauseAlreadyDelegated();
+    } else if (!errors.amount) {
+      // unidentified error case
+      errors.amount = new Error(t.taquitoError);
+      resetTotalSpent = true;
+    }
+  }
+
+  if (!errors.amount && account.balance.lte(0)) {
+    resetTotalSpent = true;
+    errors.amount = new NotEnoughBalance();
+  }
+
+  // Catch a specific case that requires a minimum amount
+  if (
+    !errors.amount &&
+    t.mode === "send" &&
+    t.amount.lt(EXISTENTIAL_DEPOSIT) &&
+    (await api.getAccountByAddress(t.recipient)).type === "empty"
+  ) {
+    resetTotalSpent = true;
+    errors.amount = new NotEnoughBalanceBecauseDestinationNotCreated("", {
+      minimalAmount: "0.275 XTZ",
+    });
+  }
+
+  const result = {
+    errors,
+    warnings,
+    estimatedFees,
+    amount: t.amount,
+    totalSpent: resetTotalSpent ? new BigNumber(0) : t.amount.plus(estimatedFees),
+  };
+  return Promise.resolve(result);
+};