@ledgerhq/coin-tezos 0.4.0-nightly.0

package/src/bridge/createTransaction.ts

@@ -0,0 +1,18 @@
+import BigNumber from "bignumber.js";
+import { Transaction } from "../types";
+
+export default function createTransaction(): Transaction {
+  return {
+    family: "tezos",
+    mode: "send",
+    amount: new BigNumber(0),
+    fees: null,
+    gasLimit: null,
+    storageLimit: null,
+    recipient: "",
+    networkInfo: null,
+    useAllAmount: false,
+    taquitoError: null,
+    estimatedFees: null,
+  };
+}

package/src/bridge/deviceTransactionConfig.ts

@@ -0,0 +1,74 @@
+import type { AccountLike, Account } from "@ledgerhq/types-live";
+import type { CommonDeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import type { Transaction, TransactionStatus } from "../types";
+
+export type ExtraDeviceTransactionField =
+  | {
+      type: "tezos.delegateValidator";
+      label: string;
+    }
+  | {
+      type: "tezos.storageLimit";
+      label: string;
+    };
+type DeviceTransactionField = CommonDeviceTransactionField | ExtraDeviceTransactionField;
+
+function getDeviceTransactionConfig({
+  account,
+  parentAccount,
+  transaction: { mode, recipient },
+  status: { amount, estimatedFees },
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const source = mainAccount.freshAddress;
+  const isDelegateOperation = mode === "delegate";
+  const fields: Array<DeviceTransactionField> = [
+    {
+      type: "address",
+      label: "Source",
+      address: source,
+    },
+  ];
+
+  if (isDelegateOperation) {
+    fields.push(
+      {
+        type: "tezos.delegateValidator",
+        label: "Validator",
+      },
+      {
+        type: "address",
+        label: "Delegate",
+        address: recipient,
+      },
+    );
+  }
+
+  if (!amount.isZero()) {
+    fields.push({
+      type: "amount",
+      label: "Amount",
+    });
+  }
+
+  if (!estimatedFees.isZero()) {
+    fields.push({
+      type: "fees",
+      label: "Fees",
+    });
+  }
+
+  fields.push({
+    type: "tezos.storageLimit",
+    label: "Storage Limit",
+  });
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/bridge/estimateMaxSpendable.ts

@@ -0,0 +1,32 @@
+import BigNumber from "bignumber.js";
+import { Account, AccountLike } from "@ledgerhq/types-live";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import { TezosAccount, Transaction } from "../types";
+import prepareTransaction from "./prepareTransaction";
+import createTransaction from "./createTransaction";
+import { getTransactionStatus } from "./transactionStatus";
+
+const TEZOS_BURN_ADDRESS = "tz1burnburnburnburnburnburnburjAYjjX";
+
+const estimateMaxSpendable = async ({
+  account,
+  parentAccount,
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount: Account | undefined;
+  transaction: Transaction;
+}): Promise<BigNumber> => {
+  const mainAccount = getMainAccount(account, parentAccount) as TezosAccount;
+  const t = await prepareTransaction(mainAccount, {
+    ...createTransaction(),
+    ...transaction,
+    // estimate using a burn address that exists so we don't enter into NotEnoughBalanceBecauseDestinationNotCreated
+    recipient: transaction?.recipient || TEZOS_BURN_ADDRESS,
+    useAllAmount: true,
+  });
+  const s = await getTransactionStatus(mainAccount, t);
+  return s.amount;
+};
+
+export default estimateMaxSpendable;

package/src/bridge/getAccountShape.test.ts

@@ -0,0 +1,22 @@
+import { getEnv, setEnv } from "@ledgerhq/live-env";
+import { fetchAllTransactions } from "./getAccountShape";
+
+jest.setTimeout(2 * 60 * 1000);
+
+describe("TEZOS_MAX_TX_QUERIES", () => {
+  const bigAccount = "tz1boBHAVpwcvKkNFAQHYr7mjxAz1PpVgKq7";
+  test("default have more than 100 txs", async () => {
+    const txs = await fetchAllTransactions(bigAccount);
+    expect(txs.length).toBeGreaterThan(100);
+  });
+  test("lowering it to 1 will only fetch a few txs", async () => {
+    const cur = getEnv("TEZOS_MAX_TX_QUERIES");
+    setEnv("TEZOS_MAX_TX_QUERIES", 1);
+    try {
+      const txs = await fetchAllTransactions(bigAccount);
+      expect(txs.length).toBeLessThanOrEqual(100);
+    } finally {
+      setEnv("TEZOS_MAX_TX_QUERIES", cur);
+    }
+  });
+});

package/src/bridge/getAccountShape.ts

@@ -0,0 +1,289 @@
+import { BigNumber } from "bignumber.js";
+import invariant from "invariant";
+import bs58check from "bs58check";
+import blake2b from "blake2b";
+import { log } from "@ledgerhq/logs";
+import { getEnv } from "@ledgerhq/live-env";
+import type { Account, OperationType, TokenAccount } from "@ledgerhq/types-live";
+import {
+  areAllOperationsLoaded,
+  decodeAccountId,
+  encodeAccountId,
+} from "@ledgerhq/coin-framework/account/index";
+import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import api, { type APIOperation } from "../api/tzkt";
+import { TezosOperation } from "../types";
+
+function reconciliatePublicKey(
+  publicKey: string | undefined,
+  initialAccount: Account | undefined,
+): string {
+  if (publicKey) return publicKey;
+  if (initialAccount) {
+    const { xpubOrAddress } = decodeAccountId(initialAccount.id);
+    return xpubOrAddress;
+  }
+  throw new Error("publicKey wasn't properly restored");
+}
+
+const encodeAddress = (publicKey: Buffer) => {
+  const curve = 0;
+  const curveData = {
+    pkB58Prefix: Buffer.from([13, 15, 37, 217]),
+    pkhB58Prefix: Buffer.from([6, 161, 159]),
+    compressPublicKey: (publicKey: Buffer, curve: number) => {
+      publicKey = publicKey.slice(0);
+      publicKey[0] = curve;
+      return publicKey;
+    },
+  };
+  const publicKeyBuf = curveData.compressPublicKey(publicKey, curve);
+  const key = publicKeyBuf.slice(1);
+  const keyHashSize = 20;
+  // eslint-disable-next-line prefer-const
+  const hash = Buffer.alloc(keyHashSize);
+  const blakHash = blake2b(keyHashSize);
+  blakHash.update(key);
+  blakHash.digest(hash);
+  const address = bs58check.encode(Buffer.concat([curveData.pkhB58Prefix, hash]));
+  return address;
+};
+
+function isStringHex(s: string): boolean {
+  for (let i = 0; i < s.length; i += 2) {
+    const ss = s.slice(i, i + 2);
+    const x = parseInt(ss, 16);
+    if (Number.isNaN(x)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export const getAccountShape: GetAccountShape = async infoInput => {
+  const { initialAccount, rest, currency, derivationMode } = infoInput;
+  const publicKey = reconciliatePublicKey(rest?.publicKey, initialAccount);
+  invariant(
+    isStringHex(publicKey),
+    `Invalid public key (${publicKey}). Please reimport your Tezos accounts`,
+  );
+  const hex = Buffer.from(publicKey, "hex");
+  const address = encodeAddress(hex);
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: publicKey,
+    derivationMode,
+  });
+
+  const initialStableOperations = (
+    initialAccount && initialAccount.id === accountId ? initialAccount.operations : []
+  ) as TezosOperation[];
+
+  // fetch transactions, incrementally if possible
+  const mostRecentStableOperation = initialStableOperations[0];
+
+  const lastId =
+    initialAccount && areAllOperationsLoaded(initialAccount) && mostRecentStableOperation
+      ? mostRecentStableOperation.extra.id || undefined
+      : undefined;
+
+  const apiAccountPromise = api.getAccountByAddress(address);
+  const blocksCountPromise = api.getBlockCount();
+
+  const [apiAccount, blockHeight] = await Promise.all([apiAccountPromise, blocksCountPromise]);
+
+  if (apiAccount.type === "empty") {
+    return {
+      id: accountId,
+      xpub: publicKey,
+      freshAddress: address,
+      blockHeight,
+      lastSyncDate: new Date(),
+      tezosResources: {
+        revealed: false,
+        counter: 0,
+      },
+    };
+  }
+
+  const fullySupported = apiAccount.type === "user";
+
+  const apiOperations = fullySupported ? await fetchAllTransactions(address, lastId) : [];
+
+  const { revealed, counter } = apiAccount;
+
+  const tezosResources = {
+    revealed,
+    counter,
+  };
+
+  const balance = new BigNumber(apiAccount.balance);
+  const subAccounts: TokenAccount[] = [];
+
+  const newOps = apiOperations
+    .map(txToOp({ address, accountId }))
+    .filter(Boolean) as unknown as TezosOperation[]; // force cast because `filter(Boolean)` remove undefined and null value
+
+  const operations = mergeOps(initialStableOperations, newOps);
+
+  const accountShape = {
+    id: accountId,
+    xpub: publicKey,
+    freshAddress: address,
+    operations,
+    balance,
+    subAccounts,
+    spendableBalance: balance,
+    blockHeight,
+    lastSyncDate: new Date(),
+    tezosResources,
+  };
+
+  return accountShape;
+};
+
+const txToOp =
+  ({ address, accountId }: { address: string; accountId: string }) =>
+  (tx: APIOperation): TezosOperation | null | undefined => {
+    let type: OperationType;
+    let maybeValue;
+    let senders: string[] = [];
+    let recipients: string[] = [];
+    const hasFailed = tx.status ? tx.status !== "applied" : false;
+
+    switch (tx.type) {
+      case "transaction": {
+        const initiator = tx.initiator?.address;
+        const from = tx.sender?.address;
+        const to = tx.target?.address;
+        if (from !== address && to !== address && initiator !== address) {
+          // failsafe for a case that shouldn't happen.
+          console.warn("found tx is unrelated to account! " + tx.hash);
+          return null;
+        }
+        senders = [from || initiator || ""];
+        recipients = [to || ""];
+        if (
+          (from === address && to === address) || // self tx
+          (from !== address && to !== address) // initiator but not in from/to
+        ) {
+          // we just pay fees in that case
+          type = "FEES";
+        } else {
+          type = to === address ? "IN" : "OUT";
+          if (!hasFailed) {
+            maybeValue = new BigNumber(tx.amount || 0);
+            if (maybeValue.eq(0)) {
+              type = "FEES";
+            }
+          }
+        }
+        break;
+      }
+      case "delegation":
+        type = tx.newDelegate ? "DELEGATE" : "UNDELEGATE";
+        senders = [address];
+        // convention was to use recipient for the new delegation address or "" if undelegation
+        recipients = [tx.newDelegate ? tx.newDelegate.address : ""];
+        break;
+      case "reveal":
+        type = "REVEAL";
+        senders = [address];
+        recipients = [address];
+        break;
+      case "migration":
+        type = tx.balanceChange < 0 ? "OUT" : "IN";
+        maybeValue = new BigNumber(Math.abs(tx.balanceChange || 0));
+        senders = [address];
+        recipients = [address];
+        break;
+      case "origination":
+        type = "CREATE";
+        maybeValue = new BigNumber(tx.contractBalance || 0);
+        senders = [address];
+        recipients = [tx.originatedContract?.address || ""];
+        break;
+      case "activation":
+        type = "IN";
+        senders = [address];
+        recipients = [address];
+        maybeValue = new BigNumber(tx.balance || 0);
+        break;
+      // TODO more type of tx
+      default:
+        console.warn("unsupported tx:", tx);
+        return null;
+    }
+
+    let { hash } = tx;
+    const {
+      id,
+      allocationFee,
+      bakerFee,
+      storageFee,
+      level: blockHeight,
+      block: blockHash,
+      timestamp,
+    } = tx;
+
+    if (!hash) {
+      // in migration case, there is no hash...
+      hash = "";
+    }
+
+    let value = maybeValue || new BigNumber(0);
+    if (type === "IN" && value.eq(0)) {
+      return; // not interesting op
+    }
+
+    let fee = new BigNumber(bakerFee || 0);
+
+    if (!hasFailed) {
+      fee = fee.plus(allocationFee || 0).plus(storageFee || 0);
+    }
+
+    if (type !== "IN") {
+      value = value.plus(fee);
+    }
+
+    return {
+      id: encodeOperationId(accountId, hash, type),
+      hash,
+      type,
+      value,
+      fee,
+      senders,
+      recipients,
+      blockHeight,
+      blockHash,
+      accountId,
+      date: new Date(timestamp),
+      extra: { id },
+      hasFailed,
+    };
+  };
+
+export const fetchAllTransactions = async (
+  address: string,
+  lastId?: number,
+): Promise<APIOperation[]> => {
+  let txs: APIOperation[] = [];
+  let maxIteration = getEnv("TEZOS_MAX_TX_QUERIES");
+  do {
+    const r = await api.getAccountOperations(address, { lastId, sort: 0 });
+    if (r.length === 0) return txs;
+    txs = txs.concat(r);
+    const last = txs[txs.length - 1];
+    if (!last) return txs;
+    lastId = last.id;
+    if (!lastId) {
+      log("tezos", "id missing!");
+      return txs;
+    }
+  } while (--maxIteration);
+  return txs;
+};

package/src/bridge/index.ts

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

package/src/bridge/preload.ts

@@ -0,0 +1,18 @@
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { fetchAllBakers, hydrateBakers } from "../api/bakers";
+
+export const getPreloadStrategy = (_currency: CryptoCurrency) => ({
+  preloadMaxAge: 30 * 1000,
+});
+
+export const preload = async () => {
+  const bakers = await fetchAllBakers();
+  return { bakers };
+};
+
+export const hydrate = (data: any) => {
+  if (!data || typeof data !== "object") return;
+  const { bakers } = data;
+  if (!bakers || typeof bakers !== "object" || !Array.isArray(bakers)) return;
+  hydrateBakers(bakers);
+};

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,160 @@
+import BigNumber from "bignumber.js";
+import { DEFAULT_FEE, DEFAULT_STORAGE_LIMIT, Estimate, TezosToolkit } from "@taquito/taquito";
+import { DerivationType } from "@taquito/ledger-signer";
+import { compressPublicKey } from "@taquito/ledger-signer/dist/lib/utils";
+import { b58cencode, prefix, Prefix, validateAddress, ValidationResult } from "@taquito/utils";
+import { InvalidAddress, RecipientRequired } from "@ledgerhq/errors";
+import { log } from "@ledgerhq/logs";
+import { getEnv } from "@ledgerhq/live-env";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { TezosAccount, Transaction } from "../types";
+
+function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined): boolean {
+  return !a && !b ? true : !a || !b ? false : a.eq(b);
+}
+
+export const validateRecipient = (currency: CryptoCurrency, recipient: string) => {
+  let recipientError: Error | null = null;
+  const recipientWarning = null;
+  if (!recipient) {
+    recipientError = new RecipientRequired("");
+  } else if (validateAddress(recipient) !== ValidationResult.VALID) {
+    recipientError = new InvalidAddress(undefined, {
+      currencyName: currency.name,
+    });
+  }
+  return Promise.resolve({ recipientError, recipientWarning });
+};
+
+const prepareTransaction = async (
+  account: TezosAccount,
+  transaction: Transaction,
+): Promise<Transaction> => {
+  const { tezosResources } = account;
+  if (!tezosResources) throw new Error("tezosResources is missing");
+
+  if (account.balance.lte(0)) {
+    return Promise.resolve(transaction);
+  }
+
+  // basic check to confirm the transaction is "complete"
+  if (transaction.mode !== "undelegate") {
+    if (!transaction.recipient) {
+      return Promise.resolve(transaction);
+    }
+
+    const { recipientError } = await validateRecipient(account.currency, transaction.recipient);
+    if (recipientError) {
+      return Promise.resolve(transaction);
+    }
+  }
+
+  const encodedPubKey = b58cencode(
+    compressPublicKey(Buffer.from(account.xpub || "", "hex"), DerivationType.ED25519),
+    prefix[Prefix.EDPK],
+  );
+
+  const tezos = new TezosToolkit(getEnv("API_TEZOS_NODE"));
+
+  tezos.setProvider({
+    signer: {
+      publicKeyHash: async () => account.freshAddress,
+      publicKey: async () => encodedPubKey,
+      sign: () => Promise.reject(new Error("unsupported")),
+      secretKey: () => Promise.reject(new Error("unsupported")),
+    },
+  });
+
+  const tx: Transaction = { ...transaction, taquitoError: null };
+
+  let amount = transaction.amount;
+  if (transaction.useAllAmount) {
+    amount = new BigNumber(1); // send max do a pre-estimation with minimum amount (taquito refuses 0)
+  }
+
+  try {
+    let estimate: Estimate;
+    switch (transaction.mode) {
+      case "send":
+        estimate = await tezos.estimate.transfer({
+          mutez: true,
+          to: transaction.recipient,
+          amount: amount.toNumber(),
+          storageLimit: DEFAULT_STORAGE_LIMIT.ORIGINATION, // https://github.com/TezTech/eztz/blob/master/PROTO_003_FEES.md for originating an account
+        });
+        break;
+      case "delegate":
+        estimate = await tezos.estimate.setDelegate({
+          source: account.freshAddress,
+          delegate: transaction.recipient,
+        });
+        break;
+      case "undelegate":
+        estimate = await tezos.estimate.setDelegate({
+          source: account.freshAddress,
+        });
+        break;
+      default:
+        throw new Error("unsupported mode=" + transaction.mode);
+    }
+
+    if (tx.useAllAmount) {
+      const totalFees = estimate.suggestedFeeMutez + estimate.burnFeeMutez;
+      const maxAmount = account.balance
+        .minus(totalFees + (tezosResources.revealed ? 0 : DEFAULT_FEE.REVEAL))
+        .toNumber();
+      // from https://github.com/ecadlabs/taquito/blob/a70c64c4b105381bb9f1d04c9c70e8ef26e9241c/integration-tests/contract-empty-implicit-account-into-new-implicit-account.spec.ts#L33
+      // Temporary fix, see https://gitlab.com/tezos/tezos/-/issues/1754
+      // we need to increase the gasLimit and fee returned by the estimation
+      const gasBuffer = 500;
+      const MINIMAL_FEE_PER_GAS_MUTEZ = 0.1;
+      const increasedFee = (gasBuffer: number, opSize: number) => {
+        return gasBuffer * MINIMAL_FEE_PER_GAS_MUTEZ + opSize;
+      };
+      const incr = increasedFee(gasBuffer, Number(estimate.opSize));
+      tx.fees = new BigNumber(estimate.suggestedFeeMutez + incr);
+      tx.gasLimit = new BigNumber(estimate.gasLimit + gasBuffer);
+      tx.amount = maxAmount - incr > 0 ? new BigNumber(maxAmount - incr) : new BigNumber(0);
+    } else {
+      tx.fees = new BigNumber(estimate.suggestedFeeMutez);
+      tx.gasLimit = new BigNumber(estimate.gasLimit);
+      tx.storageLimit = new BigNumber(estimate.storageLimit);
+    }
+
+    tx.storageLimit = new BigNumber(estimate.storageLimit);
+    tx.estimatedFees = tx.fees;
+    if (!tezosResources.revealed) {
+      tx.estimatedFees = tx.estimatedFees.plus(DEFAULT_FEE.REVEAL);
+    }
+  } catch (e) {
+    if (typeof e !== "object" || !e) throw e;
+    if ("id" in e) {
+      tx.taquitoError = (e as { id: string }).id;
+      log("taquito-error", "taquito got error " + tx.taquitoError);
+    } else if ("status" in e) {
+      // in case of http 400, log & ignore (more case to handle)
+      log("taquito-network-error", String((e as unknown as { message: string }).message || ""), {
+        transaction: tx,
+      });
+      throw e;
+    } else {
+      throw e;
+    }
+  }
+
+  // nothing changed
+  if (
+    bnEq(tx.estimatedFees, transaction.estimatedFees) &&
+    bnEq(tx.fees, transaction.fees) &&
+    bnEq(tx.gasLimit, transaction.gasLimit) &&
+    bnEq(tx.storageLimit, transaction.storageLimit) &&
+    bnEq(tx.amount, transaction.amount) &&
+    tx.taquitoError === transaction.taquitoError
+  ) {
+    return transaction;
+  }
+
+  return tx;
+};
+
+export default prepareTransaction;