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

package/src/bridge/prepareTransaction.test.ts

@@ -1,205 +0,0 @@
-import BigNumber from "bignumber.js";
-import { createFixtureAccount, createFixtureTransaction } from "../types/bridge.fixture";
-import prepareTransaction from "./prepareTransaction";
-import { faker } from "@faker-js/faker";
-import coinConfig, { TezosCoinConfig } from "../config";
-import { mockConfig } from "../test/config";
-import { COST_PER_BYTE, getRevealFee } from "@taquito/taquito";
-
-const mockTezosEstimate = jest.fn();
-jest.mock("../logic/tezosToolkit", () => ({
-  getTezosToolkit: () => ({
-    setProvider: jest.fn(),
-    estimate: {
-      transfer: () => mockTezosEstimate(),
-    },
-  }),
-}));
-
-describe("prepareTransaction", () => {
-  beforeAll(() => {
-    coinConfig.setCoinConfig((): TezosCoinConfig => mockConfig as TezosCoinConfig);
-  });
-
-  beforeEach(() => {
-    mockTezosEstimate.mockReset();
-  });
-
-  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 () => {
-    // Given
-    const tx = createFixtureTransaction({
-      amount: BigNumber(0),
-      recipient: "tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb",
-    });
-    mockTezosEstimate.mockRejectedValue({
-      id: "proto.020-PsParisC.contract.empty_transaction",
-    });
-
-    // When
-    const newTx = await prepareTransaction(createFixtureAccount({ balance: BigNumber(10) }), tx);
-
-    // Then
-    expect(newTx.taquitoError).toEqual("proto.020-PsParisC.contract.empty_transaction");
-  });
-
-  it("returns new transaction with estimated fees by TezosToolkit", async () => {
-    // Given
-    const tx = createFixtureTransaction({
-      amount: BigNumber(200),
-      recipient: "tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb",
-    });
-    const tezosEstimate = {
-      suggestedFeeMutez: faker.number.int(20),
-      gasLimit: faker.number.int(20),
-      storageLimit: faker.number.int(20),
-    };
-    mockTezosEstimate.mockResolvedValue(tezosEstimate);
-
-    // When
-    const newTx = await prepareTransaction(createFixtureAccount({ balance: BigNumber(1_000) }), tx);
-
-    // Then
-    expect(newTx).toEqual({
-      ...tx,
-      fees: new BigNumber(tezosEstimate.suggestedFeeMutez),
-      estimatedFees: new BigNumber(tezosEstimate.suggestedFeeMutez),
-      gasLimit: new BigNumber(tezosEstimate.gasLimit),
-      storageLimit: new BigNumber(tezosEstimate.storageLimit),
-    });
-  });
-
-  it("returns new transaction with estimated fees by TezosToolkit when useAllAmount from revealed account to revealed account", async () => {
-    // Given
-    const tx = createFixtureTransaction({
-      amount: BigNumber(200),
-      recipient: "tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb",
-      useAllAmount: true,
-    });
-    const tezosEstimate = {
-      suggestedFeeMutez: faker.number.int(20),
-      gasLimit: faker.number.int(20),
-      storageLimit: faker.number.int(20),
-      opSize: faker.number.int(20),
-      burnFeeMutez: faker.number.int(0),
-    };
-    mockTezosEstimate.mockResolvedValue(tezosEstimate);
-    const account = createFixtureAccount({ balance: BigNumber(1_000) });
-
-    // When
-    const newTx = await prepareTransaction(account, tx);
-
-    // Then
-    const gasLimit = 500; // hardcoded in the function
-    const maxAmount = account.balance.minus(tezosEstimate.suggestedFeeMutez);
-
-    expect(newTx).toEqual({
-      ...tx,
-      fees: new BigNumber(tezosEstimate.suggestedFeeMutez),
-      estimatedFees: new BigNumber(tezosEstimate.suggestedFeeMutez),
-      gasLimit: new BigNumber(tezosEstimate.gasLimit),
-      storageLimit: new BigNumber(tezosEstimate.storageLimit),
-      amount: maxAmount.minus(gasLimit - (tezosEstimate.opSize + gasLimit * 0.1)),
-    });
-  });
-
-  it("returns new transaction with estimated fees by TezosToolkit when useAllAmount from revealed account to account with zero balance", async () => {
-    // Given
-    const tx = createFixtureTransaction({
-      amount: BigNumber(0),
-      recipient: "tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb",
-      useAllAmount: true,
-    });
-    const tezosEstimate = {
-      suggestedFeeMutez: faker.number.int(20),
-      gasLimit: faker.number.int(20),
-      storageLimit: faker.number.int(20),
-      opSize: faker.number.int(20),
-      burnFeeMutez: faker.number.int({ min: 1, max: 20 }),
-    };
-    mockTezosEstimate.mockResolvedValue(tezosEstimate);
-    const account = createFixtureAccount({ balance: BigNumber(1_000) });
-    // When
-    const newTx = await prepareTransaction(account, tx);
-
-    // Then
-    const gasLimit = 500; // hardcoded in the function
-    const computedFees = new BigNumber(
-      tezosEstimate.suggestedFeeMutez + tezosEstimate.burnFeeMutez - 20 * COST_PER_BYTE,
-    );
-
-    const maxAmount = account.balance.minus(computedFees);
-
-    expect(newTx).toEqual({
-      ...tx,
-      fees: new BigNumber(tezosEstimate.suggestedFeeMutez),
-      estimatedFees: new BigNumber(tezosEstimate.suggestedFeeMutez),
-      gasLimit: new BigNumber(tezosEstimate.gasLimit),
-      storageLimit: new BigNumber(tezosEstimate.storageLimit),
-      amount: maxAmount.minus(gasLimit - (tezosEstimate.opSize + gasLimit * 0.1)),
-    });
-  });
-
-  it("returns new transaction with estimated fees by TezosToolkit when useAllAmount from unrevealed account to revealed account", async () => {
-    // Given
-    const tx = createFixtureTransaction({
-      amount: BigNumber(200),
-      recipient: "tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb",
-      useAllAmount: true,
-    });
-    const tezosEstimate = {
-      suggestedFeeMutez: faker.number.int(20),
-      gasLimit: faker.number.int(20),
-      storageLimit: faker.number.int(20),
-      opSize: faker.number.int(20),
-      burnFeeMutez: faker.number.int(0),
-    };
-    mockTezosEstimate.mockResolvedValue(tezosEstimate);
-    const account = createFixtureAccount({ balance: BigNumber(1_000) });
-    account.tezosResources.revealed = false;
-    // When
-    const newTx = await prepareTransaction(account, tx);
-
-    // Then
-    const gasLimit = 500; // hardcoded in the function
-    const computedFees = new BigNumber(
-      tezosEstimate.suggestedFeeMutez + getRevealFee(account.freshAddress),
-    );
-
-    const maxAmount = account.balance.minus(computedFees);
-
-    expect(newTx).toEqual({
-      ...tx,
-      fees: new BigNumber(tezosEstimate.suggestedFeeMutez),
-      estimatedFees: new BigNumber(
-        tezosEstimate.suggestedFeeMutez + getRevealFee(account.freshAddress),
-      ),
-      gasLimit: new BigNumber(tezosEstimate.gasLimit),
-      storageLimit: new BigNumber(tezosEstimate.storageLimit),
-      amount: maxAmount.minus(gasLimit - (tezosEstimate.opSize + gasLimit * 0.1)),
-    });
-  });
-
-  // it("returns the passed transaction if fees are the same", async () => {
-  //   // Given
-  //   const fees = new BigNumber(faker.number.int(50));
-  //   mockEstimateFees.mockResolvedValue(fees);
-  //   const tx = createFixtureTransaction({ fees });
-
-  //   // When
-  //   const newTx = await prepareTransaction(createFixtureAccount(), tx);
-
-  //   // Then
-  //   expect(newTx).toBe(tx);
-  // });
-});

package/src/bridge/prepareTransaction.ts

@@ -1,69 +0,0 @@
-import BigNumber from "bignumber.js";
-import { AccountBridge } from "@ledgerhq/types-live";
-import { TezosAccount, Transaction } from "../types";
-import { validateRecipient } from "../logic";
-import getEstimatedFees from "./getFeesForTransaction";
-import coinConfig from "../config";
-
-function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined): boolean {
-  return !a && !b ? true : !a || !b ? false : a.eq(b);
-}
-
-function maxBigNumber(a: BigNumber, b: BigNumber): BigNumber {
-  return a.isGreaterThan(b) ? a : b;
-}
-
-export const prepareTransaction: AccountBridge<
-  Transaction,
-  TezosAccount
->["prepareTransaction"] = async (account, transaction) => {
-  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(transaction.recipient);
-    if (recipientError) {
-      return Promise.resolve(transaction);
-    }
-  }
-
-  const estimation = await getEstimatedFees({ account, transaction });
-  const minGasLimit = coinConfig.getCoinConfig().fees.minGasLimit;
-  const minStorageLimit = coinConfig.getCoinConfig().fees.minStorageLimit;
-  const minFees = coinConfig.getCoinConfig().fees.minFees;
-  const minEstimatedFees = coinConfig.getCoinConfig().fees.minEstimatedFees;
-
-  estimation.gasLimit = maxBigNumber(estimation.gasLimit, new BigNumber(minGasLimit));
-  estimation.storageLimit = maxBigNumber(estimation.storageLimit, new BigNumber(minStorageLimit));
-  estimation.fees = maxBigNumber(estimation.fees, new BigNumber(minFees));
-  estimation.estimatedFees = maxBigNumber(
-    estimation.estimatedFees,
-    new BigNumber(minEstimatedFees),
-  );
-  const tx: Transaction = {
-    ...transaction,
-    ...estimation,
-  };
-
-  // 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;

package/src/bridge/serialization.ts

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

@@ -1,284 +0,0 @@
-import BigNumber from "bignumber.js";
-import { getRevealFee, OpKind } from "@taquito/taquito";
-import { SignOperationEvent } from "@ledgerhq/types-live";
-import buildSignOperation, { getOperationContents } from "./signOperation";
-import config, { type TezosCoinConfig } from "../config";
-import { TezosSigner } from "../types";
-import { createFixtureAccount, createFixtureTransaction } from "../types/bridge.fixture";
-import { mockConfig } from "../test/config";
-
-const mockForgeOperations = jest.fn();
-const mockEstimateReveal = jest.fn();
-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(),
-    },
-    estimate: {
-      reveal: () => mockEstimateReveal(),
-    },
-  }),
-}));
-
-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: (arg: unknown) => mockSign(arg),
-      secretKey: () => Promise.resolve(undefined),
-    }),
-  };
-  const signerContext = <T>(_deviceId: string, fn: (signer: TezosSigner) => Promise<T>) =>
-    fn(fakeSigner);
-  const signOperation = buildSignOperation(signerContext);
-  const deviceId = "dummyDeviceId";
-
-  beforeAll(() => {
-    config.setCoinConfig((): TezosCoinConfig => mockConfig as TezosCoinConfig);
-  });
-
-  afterEach(() => {
-    mockForgeOperations.mockClear();
-    mockEstimateReveal.mockClear();
-    mockSign.mockClear();
-  });
-
-  it("returns events in the right order", done => {
-    // GIVEN
-    const account = createFixtureAccount();
-    const transaction = createFixtureTransaction({ fees: BigNumber(0) });
-    mockForgeOperations.mockResolvedValue("FORGED_OP");
-
-    // 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) });
-    mockForgeOperations.mockResolvedValue("f0463d");
-
-    // 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(mockForgeOperations).toHaveBeenCalledTimes(1);
-          expect(mockSign).toHaveBeenCalledTimes(1);
-          expect(mockSign.mock.lastCall[0]).toEqual(
-            Buffer.concat([Buffer.from("03", "hex"), Buffer.from("f0463d", "hex")]).toString("hex"),
-          );
-
-          // Cleanup
-          subscriber.unsubscribe();
-          done();
-        }
-      },
-    );
-  });
-});
-
-describe("getOperationContents - revealed account", () => {
-  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,
-      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(),
-      },
-    ]);
-    expect(mockEstimateReveal).not.toHaveBeenCalled();
-  });
-
-  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,
-      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,
-      },
-    ]);
-    expect(mockEstimateReveal).not.toHaveBeenCalled();
-  });
-
-  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,
-      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(),
-      },
-    ]);
-    expect(mockEstimateReveal).not.toHaveBeenCalled();
-  });
-
-  describe("getOperationContents - not revealed account", () => {
-    const account = createFixtureAccount({
-      freshAddress: "tz1addr",
-      // We don't use `counter` in the OperationContents computation
-      tezosResources: { revealed: false, counter: -10 },
-    });
-
-    it("mode - send", async () => {
-      // Given
-      mockEstimateReveal.mockResolvedValue({
-        gasLimit: 100,
-        storageLimit: 200,
-      });
-      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,
-        counter: 0,
-        public_key: "pk",
-        public_key_hash: "pkh",
-      });
-
-      expect(type).toBe("OUT");
-      expect(contents.length).toEqual(2);
-      expect(contents).toStrictEqual([
-        {
-          kind: OpKind.REVEAL,
-          fee: getRevealFee(account.freshAddress).toString(),
-          gas_limit: "100",
-          storage_limit: "200",
-          source: "pkh",
-          counter: "1",
-          public_key: "pk",
-        },
-        {
-          kind: OpKind.TRANSACTION,
-          amount: transaction.amount.toString(),
-          destination: transaction.recipient,
-          source: "tz1addr",
-          counter: "2",
-          fee: new BigNumber(0).toString(),
-          gas_limit: new BigNumber(0).toString(),
-          storage_limit: new BigNumber(0).toString(),
-        },
-      ]);
-      expect(mockEstimateReveal).toHaveBeenCalledTimes(1);
-    });
-  });
-});