@ledgerhq/coin-tezos 0.4.0-next.0

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,161 @@
+import BigNumber from "bignumber.js";
+import { log } from "@ledgerhq/logs";
+import { getEnv } from "@ledgerhq/live-env";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { DerivationType } from "@taquito/ledger-signer";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { InvalidAddress, RecipientRequired } from "@ledgerhq/errors";
+import { compressPublicKey } from "@taquito/ledger-signer/dist/lib/utils";
+import { b58cencode, prefix, Prefix, validateAddress, ValidationResult } from "@taquito/utils";
+import { DEFAULT_FEE, DEFAULT_STORAGE_LIMIT, Estimate, TezosToolkit } from "@taquito/taquito";
+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 });
+};
+
+export const prepareTransaction: AccountBridge<
+  Transaction,
+  TezosAccount
+>["prepareTransaction"] = async (account, 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;

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,211 @@
+import BigNumber from "bignumber.js";
+import { OpKind, TezosToolkit } from "@taquito/taquito";
+import { SignOperationEvent } from "@ledgerhq/types-live";
+import buildSignOperation, { getOperationContents } from "./signOperation";
+import { TezosSigner } from "../types";
+import { createFixtureAccount, createFixtureTransaction } from "../types/model.fixture";
+
+const mockForgeOperations = jest.fn().mockResolvedValue("FORGED_OP");
+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(),
+    },
+  }),
+}));
+
+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: () => mockSign(),
+      secretKey: () => Promise.resolve(undefined),
+    }),
+  };
+  const signerContext = <T>(_deviceId: string, fn: (signer: TezosSigner) => Promise<T>) =>
+    fn(fakeSigner);
+  const signOperation = buildSignOperation(signerContext);
+  const deviceId = "dummyDeviceId";
+
+  afterEach(() => {
+    mockForgeOperations.mockClear();
+    mockSign.mockClear();
+  });
+
+  it("returns events in the right order", done => {
+    // GIVEN
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction({ fees: BigNumber(0) });
+
+    // 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) });
+
+    // 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(mockSign).toHaveBeenCalledTimes(1);
+          expect(mockForgeOperations).toHaveBeenCalledTimes(1);
+
+          // Cleanup
+          subscriber.unsubscribe();
+          done();
+        }
+      },
+    );
+  });
+});
+
+describe("getOperationContents - revealed account", () => {
+  const tezos = new TezosToolkit("MOCK_API_KEY");
+  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,
+      tezos,
+      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(),
+      },
+    ]);
+  });
+
+  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,
+      tezos,
+      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,
+      },
+    ]);
+  });
+
+  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,
+      tezos,
+      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(),
+      },
+    ]);
+  });
+});

package/src/bridge/signOperation.ts

@@ -0,0 +1,191 @@
+import { Observable } from "rxjs";
+import { getEnv } from "@ledgerhq/live-env";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { type OperationContents } from "@taquito/rpc";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { DEFAULT_FEE, OpKind, TezosToolkit } from "@taquito/taquito";
+import type { OperationType, SignOperationEvent, AccountBridge } from "@ledgerhq/types-live";
+import type { TezosAccount, TezosSigner, Transaction, TransactionStatus } from "../types";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+
+export async function getOperationContents({
+  account,
+  transaction,
+  tezos,
+  counter,
+  public_key,
+  public_key_hash,
+}: {
+  account: TezosAccount;
+  transaction: Transaction;
+  tezos: TezosToolkit;
+  counter: number;
+  public_key: string;
+  public_key_hash: string;
+}) {
+  let type: OperationType = "NONE";
+  const { freshAddress } = account;
+
+  const transactionFees = {
+    fee: (transaction.fees || 0).toString(),
+    gas_limit: (transaction.gasLimit || 0).toString(),
+    storage_limit: (transaction.storageLimit || 0).toString(),
+  };
+
+  const contents: OperationContents[] = [];
+
+  if (!account.tezosResources.revealed) {
+    const revealFees = await tezos.estimate.reveal();
+
+    contents.push({
+      kind: OpKind.REVEAL,
+      fee: DEFAULT_FEE.REVEAL.toString(),
+      gas_limit: (revealFees?.gasLimit || 0).toString(),
+      storage_limit: (revealFees?.storageLimit || 0).toString(),
+      source: public_key_hash,
+      counter: (counter + 1).toString(),
+      public_key,
+    });
+  }
+
+  switch (transaction.mode) {
+    case "send": {
+      type = "OUT";
+
+      contents.push({
+        kind: OpKind.TRANSACTION,
+        amount: transaction.amount.toString(),
+        destination: transaction.recipient,
+        source: freshAddress,
+        counter: (counter + 1 + contents.length).toString(),
+        ...transactionFees,
+      });
+
+      break;
+    }
+    case "delegate": {
+      type = "DELEGATE";
+
+      contents.push({
+        kind: OpKind.DELEGATION,
+        source: freshAddress,
+        counter: (counter + 1 + contents.length).toString(),
+        delegate: transaction.recipient,
+        ...transactionFees,
+      });
+
+      break;
+    }
+    case "undelegate": {
+      type = "UNDELEGATE";
+
+      // we undelegate as there's no "delegate" field
+      // OpKind is still "DELEGATION"
+      contents.push({
+        kind: OpKind.DELEGATION,
+        source: freshAddress,
+        counter: (counter + 1 + contents.length).toString(),
+        ...transactionFees,
+      });
+
+      break;
+    }
+    default:
+      throw new Error("not supported");
+  }
+
+  return { type, contents };
+}
+
+export const buildSignOperation =
+  (
+    signerContext: SignerContext<TezosSigner>,
+  ): AccountBridge<Transaction, TezosAccount, TransactionStatus>["signOperation"] =>
+  ({ account, deviceId, transaction }): Observable<SignOperationEvent> =>
+    new Observable(o => {
+      let cancelled = false;
+
+      async function main() {
+        const { fees } = transaction;
+        if (!fees) throw new FeeNotLoaded();
+
+        const { freshAddressPath, freshAddress } = account;
+
+        const tezos = new TezosToolkit(getEnv("API_TEZOS_NODE"));
+
+        const signedInfo = await signerContext(deviceId, async signer => {
+          const ledgerSigner = signer.createLedgerSigner(freshAddressPath, false, 0);
+
+          tezos.setProvider({ signer: ledgerSigner });
+
+          const publicKey = await ledgerSigner.publicKey();
+          const publicKeyHash = await ledgerSigner.publicKeyHash();
+
+          const { rpc } = tezos;
+          const block = await rpc.getBlock();
+          const sourceData = await rpc.getContract(freshAddress);
+
+          o.next({ type: "device-signature-requested" });
+
+          if (cancelled) {
+            return;
+          }
+
+          const { type, contents } = await getOperationContents({
+            account,
+            transaction,
+            tezos,
+            counter: Number(sourceData.counter),
+            public_key: publicKey,
+            public_key_hash: publicKeyHash,
+          });
+
+          const forgedBytes = await rpc.forgeOperations({
+            branch: block.hash,
+            contents,
+          });
+
+          // 0x03 is a conventional prefix (aka a watermark) for tezos transactions
+          const signature = await ledgerSigner.sign(
+            Buffer.concat([Buffer.from("03", "hex"), Buffer.from(forgedBytes, "hex")]).toString(
+              "hex",
+            ),
+          );
+
+          return {
+            type,
+            signature,
+          };
+        });
+
+        if (!signedInfo) {
+          return;
+        }
+
+        o.next({ type: "device-signature-granted" });
+
+        const { type, signature } = signedInfo;
+        const operation = buildOptimisticOperation(account, transaction, type);
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            // we slice the signature to remove the `03` prefix
+            // which souldn't be included in the signature
+            signature: signature.sbytes.slice(2),
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+
+      return () => {
+        cancelled = true;
+      };
+    });
+
+export default buildSignOperation;

package/src/bridge/synchronization.test.ts

@@ -0,0 +1,22 @@
+import { getEnv, setEnv } from "@ledgerhq/live-env";
+import { fetchAllTransactions } from "../api/tzkt";
+
+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);
+    }
+  });
+});