@ledgerhq/coin-tezos 6.5.0 → 6.6.0-nightly.0

package/src/bridge/getTransactionStatus.test.ts

@@ -1,124 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,171 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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();
-  });
-});