@ledgerhq/coin-tezos 6.6.0-nightly.1 → 6.6.0

package/src/bridge/getFeesForTransaction.ts

@@ -0,0 +1,49 @@
+import BigNumber from "bignumber.js";
+import { TezosAccount, Transaction } from "../types";
+import { estimateFees } from "../logic";
+
+export type EstimatedFees = {
+  fees: BigNumber;
+  gasLimit: BigNumber;
+  storageLimit: BigNumber;
+  estimatedFees: BigNumber;
+  amount?: BigNumber;
+  taquitoError?: string;
+};
+/**
+ * Fetch the transaction fees for a transaction
+ *
+ * @param {Account} a
+ * @param {Transaction} t
+ */
+export default async function getEstimatedFees({
+  account,
+  transaction,
+}: {
+  account: TezosAccount;
+  transaction: Transaction;
+}): Promise<EstimatedFees> {
+  const estimate = await estimateFees({
+    account: {
+      xpub: account.xpub,
+      address: account.freshAddress,
+      balance: BigInt(account.balance.toString()),
+      revealed: account.tezosResources.revealed,
+    },
+    transaction: {
+      mode: transaction.mode,
+      recipient: transaction.recipient,
+      amount: BigInt(transaction.amount.toString()),
+      useAllAmount: transaction.useAllAmount,
+    },
+  });
+
+  return {
+    fees: BigNumber(estimate.fees.toString()),
+    gasLimit: BigNumber(estimate.gasLimit.toString()),
+    storageLimit: BigNumber(estimate.storageLimit.toString()),
+    estimatedFees: BigNumber(estimate.estimatedFees.toString()),
+    amount: estimate.amount !== undefined ? BigNumber(estimate.amount.toString()) : BigNumber(0),
+    taquitoError: estimate.taquitoError,
+  };
+}

package/src/bridge/getTransactionStatus.test.ts

@@ -0,0 +1,124 @@
+import BigNumber from "bignumber.js";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { validateRecipient } from "../logic";
+import { isAccountDelegating } from "../network/bakers";
+import api from "../network/tzkt";
+import {
+  AmountRequired,
+  FeeTooHigh,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  NotEnoughBalanceBecauseDestinationNotCreated,
+  RecommendUndelegation,
+} from "@ledgerhq/errors";
+import { TezosAccount, Transaction } from "../types";
+
+jest.mock("../logic", () => ({
+  validateRecipient: jest.fn(),
+}));
+
+jest.mock("../network/bakers", () => ({
+  isAccountDelegating: jest.fn(),
+}));
+
+jest.mock("../network/tzkt", () => ({
+  getAccountByAddress: jest.fn(),
+}));
+
+describe("getTransactionStatus", () => {
+  const mockAccount = {
+    type: "Account",
+    freshAddress: "tz1SourceAddress",
+    balance: new BigNumber(1000000),
+    currency: {
+      type: "CryptoCurrency",
+      units: [
+        {
+          name: "tezos",
+          code: "XTZ",
+          magnitude: 6,
+        },
+      ],
+    },
+    tezosResources: {
+      revealed: true,
+      counter: 0,
+    },
+  } as unknown as TezosAccount;
+
+  const mockTransaction = {
+    family: "tezos",
+    mode: "send",
+    amount: new BigNumber(500000),
+    recipient: "tz1RecipientAddress",
+    estimatedFees: new BigNumber(1000),
+    useAllAmount: false,
+  } as Transaction;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (validateRecipient as jest.Mock).mockResolvedValue({
+      recipientError: null,
+      recipientWarning: null,
+    });
+    (api.getAccountByAddress as jest.Mock).mockResolvedValue({ type: "empty" });
+  });
+
+  it("should return an error if the recipient is the same as the source address", async () => {
+    const transaction = { ...mockTransaction, recipient: mockAccount.freshAddress };
+    const result = await getTransactionStatus(mockAccount, transaction);
+    expect(result.errors.recipient).toBeInstanceOf(InvalidAddressBecauseDestinationIsAlsoSource);
+  });
+
+  it("should return an error if the amount is zero and useAllAmount is false", async () => {
+    const transaction = { ...mockTransaction, amount: new BigNumber(0) };
+    const result = await getTransactionStatus(mockAccount, transaction);
+    expect(result.errors.amount).toBeInstanceOf(AmountRequired);
+  });
+
+  it("should return a warning if the fees are too high compared to the amount", async () => {
+    const transaction = { ...mockTransaction, amount: new BigNumber(1000) };
+    const result = await getTransactionStatus(mockAccount, transaction);
+    expect(result.warnings.feeTooHigh).toBeInstanceOf(FeeTooHigh);
+  });
+
+  it("should return a warning if the balance after transaction is below the threshold", async () => {
+    (isAccountDelegating as jest.Mock).mockReturnValue(true);
+    const transaction = { ...mockTransaction, amount: new BigNumber(999000) };
+    const result = await getTransactionStatus(mockAccount, transaction);
+    expect(result.warnings.amount).toBeInstanceOf(RecommendUndelegation);
+  });
+
+  it("should map taquito errors to appropriate errors", async () => {
+    const transaction = { ...mockTransaction, taquitoError: "balance_too_low" };
+    const result = await getTransactionStatus(mockAccount, transaction);
+    expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance);
+  });
+
+  it("should return an error if the account balance is zero or less", async () => {
+    const account = { ...mockAccount, balance: new BigNumber(0) };
+    const result = await getTransactionStatus(account, mockTransaction);
+    expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance);
+  });
+
+  it("should return an error if the account balance is less than the estimated fees for delegation", async () => {
+    const transaction = { ...mockTransaction, mode: "delegate" } as Transaction;
+    const account = { ...mockAccount, balance: new BigNumber(500) };
+    const result = await getTransactionStatus(account, transaction);
+    expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance);
+  });
+
+  it("should return an error if the recipient account is empty and the amount is below the existential deposit", async () => {
+    const transaction = { ...mockTransaction, amount: new BigNumber(100000) };
+    const result = await getTransactionStatus(mockAccount, transaction);
+    expect(result.errors.amount).toBeInstanceOf(NotEnoughBalanceBecauseDestinationNotCreated);
+  });
+
+  it("should return no errors or warnings for a valid transaction", async () => {
+    const account = { ...mockAccount, balance: new BigNumber(2000000) };
+    const transaction = { ...mockTransaction, amount: new BigNumber(500000) };
+    const result = await getTransactionStatus(account, transaction);
+    expect(result.errors).toEqual({});
+    expect(result.warnings).toEqual({});
+  });
+});

package/src/bridge/getTransactionStatus.ts

@@ -0,0 +1,123 @@
+import {
+  AmountRequired,
+  FeeTooHigh,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  NotEnoughBalanceBecauseDestinationNotCreated,
+  NotEnoughBalanceToDelegate,
+  RecommendUndelegation,
+} from "@ledgerhq/errors";
+import { log } from "@ledgerhq/logs";
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { InvalidAddressBecauseAlreadyDelegated } from "../types/errors";
+import { validateRecipient } from "../logic";
+import { isAccountDelegating } from "../network/bakers";
+import api from "../network/tzkt";
+import { Transaction } from "../types";
+
+const EXISTENTIAL_DEPOSIT = new BigNumber(275000);
+
+export const getTransactionStatus: AccountBridge<Transaction>["getTransactionStatus"] = async (
+  account,
+  transaction,
+) => {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+  let resetTotalSpent = false;
+
+  // Recipient validation logic
+  if (transaction.mode !== "undelegate") {
+    if (account.freshAddress === transaction.recipient) {
+      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+    } else {
+      const { recipientError, recipientWarning } = await validateRecipient(transaction.recipient);
+      if (recipientError) {
+        errors.recipient = recipientError;
+      }
+      if (recipientWarning) {
+        warnings.recipient = recipientWarning;
+      }
+    }
+  }
+
+  // Pre validation of amount field
+  const estimatedFees = transaction.estimatedFees || new BigNumber(0);
+  if (transaction.mode === "send") {
+    if (!errors.amount && transaction.amount.eq(0) && !transaction.useAllAmount) {
+      resetTotalSpent = true;
+      errors.amount = new AmountRequired();
+    } else if (transaction.amount.gt(0) && estimatedFees.times(10).gt(transaction.amount)) {
+      warnings.feeTooHigh = new FeeTooHigh();
+    }
+    const thresholdWarning = 0.5 * 10 ** account.currency.units[0].magnitude;
+    if (
+      !errors.amount &&
+      account.balance.minus(transaction.amount).minus(estimatedFees).lt(thresholdWarning)
+    ) {
+      if (isAccountDelegating(account)) {
+        if (transaction.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 (transaction.taquitoError) {
+    log("taquitoerror", String(transaction.taquitoError));
+
+    // remap taquito errors
+    if (
+      transaction.taquitoError.endsWith("balance_too_low") ||
+      transaction.taquitoError.endsWith("subtraction_underflow")
+    ) {
+      if (transaction.mode === "send") {
+        resetTotalSpent = true;
+        errors.amount = new NotEnoughBalance();
+      } else {
+        errors.amount = new NotEnoughBalanceToDelegate();
+      }
+    } else if (transaction.taquitoError.endsWith("delegate.unchanged")) {
+      errors.recipient = new InvalidAddressBecauseAlreadyDelegated();
+    } else if (!errors.amount) {
+      // unidentified error case
+      errors.amount = new Error(transaction.taquitoError);
+      resetTotalSpent = true;
+    }
+  }
+
+  if (!errors.amount && account.balance.lte(0)) {
+    resetTotalSpent = true;
+    errors.amount = new NotEnoughBalance();
+  }
+
+  if (!errors.amount && transaction.mode === "delegate" && account.balance.lte(estimatedFees)) {
+    resetTotalSpent = true;
+    errors.amount = new NotEnoughBalance();
+  }
+
+  // Catch a specific case that requires a minimum amount
+  if (
+    !errors.amount &&
+    transaction.mode === "send" &&
+    transaction.amount.lt(EXISTENTIAL_DEPOSIT) &&
+    (await api.getAccountByAddress(transaction.recipient)).type === "empty"
+  ) {
+    resetTotalSpent = true;
+    errors.amount = new NotEnoughBalanceBecauseDestinationNotCreated("", {
+      minimalAmount: "0.275 XTZ",
+    });
+  }
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount: transaction.amount,
+    totalSpent: resetTotalSpent ? new BigNumber(0) : transaction.amount.plus(estimatedFees),
+  };
+};

package/src/bridge/index.ts

@@ -0,0 +1,74 @@
+import {
+  getSerializedAddressParameters,
+  updateTransaction,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { CoinConfig } from "@ledgerhq/coin-framework/config";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { CurrencyBridge, AccountBridge } from "@ledgerhq/types-live";
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import type { TezosAccount, TezosSigner, Transaction, TransactionStatus } from "../types";
+import { assignFromAccountRaw, assignToAccountRaw } from "./serialization";
+import { getPreloadStrategy, hydrate, preload } from "./preload";
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { prepareTransaction } from "./prepareTransaction";
+import { getAccountShape, sync } from "./synchronization";
+import { createTransaction } from "./createTransaction";
+import { buildSignOperation } from "./signOperation";
+import signerGetAddress from "../signer";
+import { broadcast } from "./broadcast";
+import tezosCoinConfig, { TezosCoinConfig } from "../config";
+
+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, TezosAccount, TransactionStatus> {
+  const getAddress = signerGetAddress(signerContext);
+
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+  const signOperation = buildSignOperation(signerContext);
+
+  return {
+    estimateMaxSpendable,
+    createTransaction,
+    updateTransaction,
+    getTransactionStatus,
+    prepareTransaction,
+    sync,
+    receive,
+    signOperation,
+    broadcast,
+    assignFromAccountRaw,
+    assignToAccountRaw,
+    getSerializedAddressParameters,
+  };
+}
+
+export function createBridges(
+  signerContext: SignerContext<TezosSigner>,
+  coinConfig: CoinConfig<TezosCoinConfig>,
+) {
+  tezosCoinConfig.setCoinConfig(coinConfig);
+
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext),
+    accountBridge: buildAccountBridge(signerContext),
+  };
+}

package/src/bridge/logic.ts

@@ -0,0 +1,171 @@
+import { blake2b } from "@noble/hashes/blake2";
+import bs58check from "bs58check";
+import BigNumber from "bignumber.js";
+import { OperationType } from "@ledgerhq/types-live";
+import { decodeAccountId } from "@ledgerhq/coin-framework/account";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { type APIOperation } from "../network/types";
+import { TezosAccount, TezosOperation } from "../types";
+
+export 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 function reconciliatePublicKey(
+  publicKey: string | undefined,
+  account: TezosAccount | undefined,
+): string {
+  if (publicKey) return publicKey;
+  if (account) {
+    const { xpubOrAddress } = decodeAccountId(account.id);
+    return xpubOrAddress;
+  }
+  throw new Error("publicKey wasn't properly restored");
+}
+
+export function 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;
+  const hash = Buffer.from(blake2b(key, { dkLen: keyHashSize }));
+  const address = bs58check.encode(Buffer.concat([curveData.pkhB58Prefix, hash]));
+  return address;
+}
+
+export 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;
+}

package/src/bridge/preload.ts

@@ -0,0 +1,18 @@
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { fetchAllBakers, hydrateBakers } from "../network/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.integ.test.ts

@@ -0,0 +1,35 @@
+import BigNumber from "bignumber.js";
+import { createFixtureAccount, createFixtureTransaction } from "../types/bridge.fixture";
+import prepareTransaction from "./prepareTransaction";
+import coinConfig, { TezosCoinConfig } from "../config";
+import { mockConfig } from "../test/config";
+
+describe.only("prepareTransaction", () => {
+  beforeAll(() => {
+    coinConfig.setCoinConfig((): TezosCoinConfig => mockConfig as TezosCoinConfig);
+  });
+
+  it("returns the same transaction when account balance is 0", async () => {
+    // Given
+    const tx = createFixtureTransaction({ amount: BigNumber(0) });
+
+    // When
+    const newTx = await prepareTransaction(createFixtureAccount(), tx);
+
+    // Then
+    expect(newTx).toBe(tx);
+  });
+
+  it("returns error when amount is 0", async () => {
+    const tx = createFixtureTransaction({
+      amount: BigNumber(0),
+      recipient: "tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb",
+    });
+
+    const newTx = await prepareTransaction(createFixtureAccount({ balance: BigNumber(10) }), tx);
+
+    // initial expectation was proto.020-PsParisC.contract.empty_transaction
+    // and evolved to proto.021-PsQuebec.contract.empty_transaction
+    expect(newTx.taquitoError?.includes(".contract.empty_transaction")).toBeTruthy();
+  });
+});