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

package/src/bridge/prepareTransaction.test.ts

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

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

@@ -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,284 @@
+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);
+    });
+  });
+});