@ledgerhq/coin-tezos 0.4.0-nightly.0

package/package.json

@@ -0,0 +1,116 @@
+{
+  "name": "@ledgerhq/coin-tezos",
+  "version": "0.4.0-nightly.0",
+  "description": "Tezos Coin integration",
+  "keywords": [
+    "Ledger",
+    "LedgerWallet",
+    "tezos",
+    "Tezos",
+    "Hardware Wallet"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LedgerHQ/ledger-live.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LedgerHQ/ledger-live/issues"
+  },
+  "homepage": "https://github.com/LedgerHQ/ledger-live/tree/develop/libs/coin-modules/coin-tezos",
+  "publishConfig": {
+    "access": "public"
+  },
+  "typesVersions": {
+    "*": {
+      "lib/*": [
+        "lib/*"
+      ],
+      "lib-es/*": [
+        "lib-es/*"
+      ],
+      "specs": [
+        "lib/test/bot-specs"
+      ],
+      "*": [
+        "lib/*",
+        "lib/bridge/*",
+        "lib/signer/*",
+        "lib/test/*",
+        "lib/types/*"
+      ]
+    }
+  },
+  "exports": {
+    "./lib/*": "./lib/*.js",
+    "./lib-es/*": "./lib-es/*.js",
+    "./deviceTransactionConfig": {
+      "require": "./lib/bridge/deviceTransactionConfig.js",
+      "default": "./lib-es/bridge/deviceTransactionConfig.js"
+    },
+    "./errors": {
+      "require": "./lib/types/errors.js",
+      "default": "./lib-es/types/errors.js"
+    },
+    "./specs": {
+      "require": "./lib/test/bot-specs.js",
+      "default": "./lib-es/test/bot-specs.js"
+    },
+    "./transaction": {
+      "require": "./lib/bridge/transaction.js",
+      "default": "./lib-es/bridge/transaction.js"
+    },
+    "./*": {
+      "require": "./lib/*.js",
+      "default": "./lib-es/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@taquito/ledger-signer": "^13.0.1",
+    "@taquito/rpc": "^13.0.1",
+    "@taquito/taquito": "^13.0.1",
+    "@taquito/utils": "^13.0.1",
+    "bignumber.js": "^9.1.2",
+    "blake2b": "^2.1.4",
+    "bs58check": "^2.1.2",
+    "invariant": "^2.2.2",
+    "lodash": "^4.17.21",
+    "rxjs": "^7.8.1",
+    "@ledgerhq/coin-framework": "^0.13.1-nightly.1",
+    "@ledgerhq/cryptoassets": "^13.1.0-nightly.0",
+    "@ledgerhq/devices": "^8.3.0",
+    "@ledgerhq/errors": "^6.16.4",
+    "@ledgerhq/live-env": "^2.0.2",
+    "@ledgerhq/live-network": "^1.2.2",
+    "@ledgerhq/logs": "^6.12.0",
+    "@ledgerhq/types-cryptoassets": "^7.12.0",
+    "@ledgerhq/types-live": "^6.47.0"
+  },
+  "devDependencies": {
+    "@faker-js/faker": "^8.4.1",
+    "@types/invariant": "^2.2.2",
+    "@types/jest": "^29.5.10",
+    "@types/lodash": "^4.14.191",
+    "@types/blake2b": "^2.1.3",
+    "@types/bs58check": "^2.1.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1"
+  },
+  "overrides": {
+    "@taquito/ledger-signer": {
+      "@ledgerhq/hw-transport": "../_EXCLUDED_"
+    }
+  },
+  "scripts": {
+    "clean": "rimraf lib lib-es",
+    "build": "tsc && tsc -m ES6 --outDir lib-es",
+    "prewatch": "pnpm build",
+    "watch": "tsc --watch",
+    "doc": "documentation readme src/** --section=API --pe ts --re ts --re d.ts",
+    "lint": "eslint ./src --no-error-on-unmatched-pattern --ext .ts,.tsx --cache",
+    "lint:fix": "pnpm lint --fix",
+    "test": "jest",
+    "unimported": "unimported"
+  }
+}

package/src/README.md

@@ -0,0 +1,29 @@
+# Tezos integration
+
+## Status
+
+This coin integration is being reworked from a C++ in-house implementation into a JavaScript integration.
+
+## Environment
+
+Here is a quick summary of how this integration is made:
+
+- Taquito library
+- Ledger's self hosted tzkt.io API
+- Ledger's own node
+
+## Account ID, public key and addresses
+
+The account id have the shape `{impl}:{version}:{currency}:{pubkey}:{derivation}`
+
+For instance: `js:2:tezos:02e9d3749ffd715be88b9bc9f1afd0470e66b867042d2862c61f335a76e4d37af0:tezbox`
+
+The public key is the account main identifier, expressed as uncompress hex: `02e9d3749ffd715be88b9bc9f1afd0470e66b867042d2862c61f335a76e4d37af0`.
+
+This public key is needed for making transaction and also is used to hash the account address. (`tz1PTxfn1fge2tJwGGpW9zNuYf6BseM3GJXt` in this case)
+
+The Account type as defined in https://github.com/LedgerHQ/ledger-live/wiki/LLC:account will be used with:
+
+- `.id` to be the id explained as above
+- `.xpub` to be the public key
+- `.freshAddress` to be the tezos account address

package/src/api/bakers.integration.test.ts

@@ -0,0 +1,61 @@
+import { DerivationMode } from "@ledgerhq/types-live";
+import { fromAccountRaw } from "@ledgerhq/coin-framework/serialization";
+import { TezosAccountRaw } from "../types";
+import { loadAccountDelegation, listBakers } from "../api/bakers";
+import whitelist from "../api/bakers.whitelist-default";
+
+function makeAccountRaw(
+  name: string,
+  pubkey: string,
+  address: string,
+  derivationMode: DerivationMode,
+): TezosAccountRaw {
+  return {
+    id: `js:2:tezos:${pubkey}:${derivationMode}`,
+    seedIdentifier: address,
+    name: "Tezos " + name,
+    derivationMode,
+    index: 0,
+    freshAddress: address,
+    freshAddressPath: "",
+    blockHeight: 0,
+    operations: [],
+    pendingOperations: [],
+    currencyId: "tezos",
+    lastSyncDate: "",
+    balance: "0",
+    xpub: pubkey,
+    subAccounts: [],
+    tezosResources: { revealed: true, counter: 0 },
+  };
+}
+
+const accountTZrevealedDelegating = makeAccountRaw(
+  "TZrevealedDelegating",
+  "02389ffd73423626894cb151416e51c72ec285376673daf83545eb5edb45b261ce",
+  "tz1boBHAVpwcvKkNFAQHYr7mjxAz1PpVgKq7",
+  "tezbox",
+);
+
+describe("tezos bakers", () => {
+  test("atleast 10 whitelisted bakers are online", async () => {
+    const bakers = await listBakers(whitelist);
+    const retrievedAddresses = bakers.map(o => o.address);
+    let available = 0;
+    for (const whitelisted of whitelist) {
+      if (retrievedAddresses.includes(whitelisted)) {
+        available++;
+      } else {
+        console.warn(`Baker ${whitelisted} no longer online !`);
+      }
+    }
+    expect(available).toBeGreaterThan(10);
+  });
+
+  // TODO we'll need two accounts to test diff cases
+  test("load account baker info", async () => {
+    const account = fromAccountRaw(accountTZrevealedDelegating);
+    const delegation = await loadAccountDelegation(account);
+    expect(delegation).toBe(null);
+  });
+});

package/src/api/bakers.test.ts

@@ -0,0 +1,140 @@
+import network from "@ledgerhq/live-network/network";
+import { API_BAKER } from "../types";
+import { asBaker, cache } from "./bakers";
+
+jest.mock("@ledgerhq/live-network/network");
+const mockedNetwork = jest.mocked(network);
+
+const data: API_BAKER[] = [
+  {
+    address: "tz1Kf25fX1VdmYGSEzwFy1wNmkbSEZ2V83sY",
+    name: "Tezos Seoul",
+    logo: "https://services.tzkt.io/v1/avatars/tz1Kf25fX1VdmYGSEzwFy1wNmkbSEZ2V83sY",
+    balance: 155309.245322,
+    stakingBalance: 1478612.577008,
+    stakingCapacity: 1500000,
+    maxStakingBalance: 1425000,
+    freeSpace: -53612.57700800011,
+    fee: 0.07,
+    minDelegation: 100,
+    payoutDelay: 6,
+    payoutPeriod: 1,
+    openForDelegation: true,
+    estimatedRoi: 0.056842,
+    serviceType: "tezos_only",
+    serviceHealth: "active",
+    payoutTiming: "stable",
+    payoutAccuracy: "precise",
+    audit: "5fa0308f48ca160f9901116a",
+    insuranceCoverage: 0,
+  },
+  {
+    address: "tz1gg5bjopPcr9agjamyu9BbXKLibNc2rbAq",
+    name: "hodl.farm",
+    logo: "https://services.tzkt.io/v1/avatars/tz1gg5bjopPcr9agjamyu9BbXKLibNc2rbAq",
+    balance: 33273.028666,
+    stakingBalance: 335991.478219,
+    stakingCapacity: 326500,
+    maxStakingBalance: 326500,
+    freeSpace: -9491.478218999982,
+    fee: 0.05,
+    minDelegation: 0,
+    payoutDelay: -5,
+    payoutPeriod: 1,
+    openForDelegation: true,
+    estimatedRoi: 0.056424,
+    serviceType: "tezos_only",
+    serviceHealth: "active",
+    payoutTiming: "stable",
+    payoutAccuracy: "inaccurate",
+    audit: "64bd3910d0970a602a90d497",
+    insuranceCoverage: 0,
+  },
+  {
+    address: "tz3LV9aGKHDnAZHCtC9SjNtTrKRu678FqSki",
+    name: "Ledger Live by Kiln",
+    logo: "https://services.tzkt.io/v1/avatars/tz3LV9aGKHDnAZHCtC9SjNtTrKRu678FqSki",
+    balance: 708166.216593,
+    stakingBalance: 708166.216593,
+    stakingCapacity: 7081662.16593,
+    maxStakingBalance: 7081662.16593,
+    freeSpace: 6373495.949337,
+    fee: 0.12,
+    minDelegation: 1,
+    payoutDelay: 1,
+    payoutPeriod: 1,
+    openForDelegation: true,
+    estimatedRoi: 0.053786,
+    serviceType: "tezos_only",
+    serviceHealth: "active",
+    payoutTiming: "no_data",
+    payoutAccuracy: "no_data",
+    insuranceCoverage: 0,
+  },
+  {
+    address: "tz1KwafrdmM8RwxUMxdbbtWyZuKLWSPVxe9u",
+    name: "Tezberry Pie",
+    logo: "https://services.tzkt.io/v1/avatars/tz1KwafrdmM8RwxUMxdbbtWyZuKLWSPVxe9u",
+    balance: 9048.905456,
+    stakingBalance: 66542.819025,
+    stakingCapacity: 72000,
+    maxStakingBalance: 72000,
+    freeSpace: 5457.180974999996,
+    fee: 0.12,
+    minDelegation: 10,
+    payoutDelay: 1,
+    payoutPeriod: 1,
+    openForDelegation: true,
+    estimatedRoi: 0.053786,
+    serviceType: "tezos_only",
+    serviceHealth: "active",
+    payoutTiming: "stable",
+    payoutAccuracy: "inaccurate",
+    audit: "63692a2ca6632298f27ed744",
+    insuranceCoverage: 0,
+  },
+];
+
+describe("Tezos Baker", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+    cache.reset();
+  });
+
+  describe("Get bakers from cache", () => {
+    beforeEach(() => {
+      const response = {
+        data,
+        status: 200,
+        headers: {},
+        statusText: "",
+        config: {},
+      };
+
+      mockedNetwork.mockReturnValue(Promise.resolve(response));
+    });
+
+    it("Ledger Baker should be first in the list", async () => {
+      const bakers = await cache();
+      expect(bakers[0].name).toBe("Ledger Live by Kiln");
+    });
+  });
+
+  describe("asBaker", () => {
+    it("Should convert api baker to LL baker (capacity status full)", () => {
+      const testBaker = data.find(baker => baker.freeSpace < 0)!;
+      const baker = asBaker(testBaker);
+      expect(baker?.name).toBe(testBaker.name);
+      expect(baker?.nominalYield).toBe(`${Math.floor(10000 * testBaker.estimatedRoi) / 100} %`);
+      expect(baker?.capacityStatus).toBe("full");
+    });
+
+    it("Should convert api baker to LL baker (capacity status normal)", () => {
+      const testBaker = data.find(baker => baker.freeSpace > 0)!;
+      const baker = asBaker(testBaker);
+      expect(baker?.name).toBe(testBaker.name);
+      expect(baker?.nominalYield).toBe(`${Math.floor(10000 * testBaker.estimatedRoi) / 100} %`);
+      expect(baker?.capacityStatus).toBe("normal");
+    });
+  });
+});

package/src/api/bakers.ts

@@ -0,0 +1,139 @@
+import { makeLRUCache } from "@ledgerhq/live-network/cache";
+import network from "@ledgerhq/live-network/network";
+import { log } from "@ledgerhq/logs";
+import type { AccountLike } from "@ledgerhq/types-live";
+import { getEnv } from "@ledgerhq/live-env";
+import { ledgerValidatorAddress } from "./bakers.whitelist-default";
+import { API_BAKER, Baker, Delegation } from "../types";
+
+export const cache = makeLRUCache(
+  async (): Promise<Baker[]> => {
+    const bakers: Baker[] = [];
+    const TEZOS_API_BASE_URL = getEnv("API_TEZOS_BAKER");
+    const { data } = await network<API_BAKER[]>({
+      url: `${TEZOS_API_BASE_URL}/v2/bakers`,
+    });
+
+    if (data && Array.isArray(data)) {
+      log("tezos/bakers", "found " + data.length + " bakers");
+      data
+        .filter(raw => raw.serviceHealth === "active")
+        .forEach(raw => {
+          const baker = asBaker(raw);
+
+          if (baker) {
+            bakers.push(baker);
+          }
+        });
+    }
+
+    const ledgerBakerIndex = bakers.findIndex(baker => baker.address === ledgerValidatorAddress);
+    const [ledgerBaker] = bakers.splice(ledgerBakerIndex, 1);
+
+    log("tezos/bakers", "loaded " + bakers.length + " bakers");
+    return [ledgerBaker, ...bakers];
+  },
+  () => "",
+);
+
+let _lastBakers: Baker[] = [];
+
+export const fetchAllBakers = async (): Promise<Baker[]> => {
+  const allBakers = await cache.force();
+  _lastBakers = allBakers;
+  return allBakers;
+};
+
+function whitelist(all: Baker[], addresses: string[]) {
+  return all.filter(baker => addresses.includes(baker.address));
+}
+export const listBakersWithDefault = (whitelistAddresses: string[]): Baker[] => {
+  return whitelist(_lastBakers, whitelistAddresses);
+};
+
+export const listBakers = async (whitelistAddresses: string[]): Promise<Baker[]> => {
+  _lastBakers = await cache();
+  return whitelist(_lastBakers, whitelistAddresses);
+};
+
+export function getBakerSync(addr: string): Baker | undefined {
+  return _lastBakers.find(baker => baker.address === addr);
+}
+
+export function getAccountDelegationSync(account: AccountLike): Delegation | null | undefined {
+  const op = account.operations.find(
+    op => !op.hasFailed && (op.type === "DELEGATE" || op.type === "UNDELEGATE"),
+  );
+  const pendingOp = account.pendingOperations
+    .filter(op => !account.operations.some(o => op.hash === o.hash))
+    .find(op => op.type === "DELEGATE" || op.type === "UNDELEGATE");
+  const isPending = !!pendingOp;
+  const operation = pendingOp && pendingOp.type === "DELEGATE" ? pendingOp : op;
+
+  if (!operation || operation.type === "UNDELEGATE") {
+    return null;
+  }
+
+  const recentOps = account.operations
+    .filter(op => op.date > operation.date)
+    .concat(account.pendingOperations);
+  const sendShouldWarnDelegation = !recentOps.some(op => op.type === "OUT");
+  const receiveShouldWarnDelegation = !recentOps.some(op => op.type === "IN");
+  return {
+    isPending,
+    operation,
+    address: operation.recipients[0],
+    baker: null,
+    sendShouldWarnDelegation,
+    receiveShouldWarnDelegation,
+  };
+}
+
+export function isAccountDelegating(account: AccountLike): boolean {
+  return !!getAccountDelegationSync(account);
+}
+
+export async function loadBaker(addr: string): Promise<Baker | undefined> {
+  const cacheBaker = getBakerSync(addr);
+  if (cacheBaker) return cacheBaker;
+  const bakers = await cache();
+  const baker = bakers.find(baker => baker.address === addr);
+  return baker;
+}
+
+export async function loadAccountDelegation(
+  account: AccountLike,
+): Promise<Delegation | null | undefined> {
+  const delegation = getAccountDelegationSync(account);
+  if (!delegation) return null;
+  const baker = await loadBaker(delegation.address);
+  return { ...delegation, baker };
+}
+
+export const asBaker = (data: API_BAKER): Baker | undefined => {
+  const { address, name, logo, freeSpace, estimatedRoi } = data;
+
+  if (
+    typeof name === "string" &&
+    typeof address === "string" &&
+    typeof logo === "string" &&
+    typeof freeSpace === "number" &&
+    typeof estimatedRoi === "number" &&
+    (logo.startsWith("https://") || logo.startsWith("http://")) &&
+    estimatedRoi >= 0 &&
+    estimatedRoi <= 1
+  ) {
+    return {
+      name,
+      address,
+      logoURL: logo,
+      nominalYield: `${Math.floor(10000 * estimatedRoi) / 100} %`,
+      capacityStatus: freeSpace <= 0 ? "full" : "normal",
+    };
+  }
+};
+
+export const hydrateBakers = (bakers: Baker[]): void => {
+  log("tezos/bakers", "hydrate " + bakers.length + " bakers");
+  cache.hydrate("", bakers);
+};

package/src/api/bakers.whitelist-default.ts

@@ -0,0 +1,33 @@
+export const ledgerValidatorAddress = "tz3LV9aGKHDnAZHCtC9SjNtTrKRu678FqSki";
+const whitelist = [
+  "tz1WCd2jm4uSt4vntk4vSuUWoZQGhLcDuR9q",
+  "tz1Scdr2HsZiQjc7bHMeBbmDRXYVvdhjJbBh",
+  "tz1g8vkmcde6sWKaG2NN9WKzCkDM6Rziq194",
+  "tz1PWCDnz783NNGGQjEFFsHtrcK5yBW4E2rm",
+  "tz1RV1MBbZMR68tacosb7Mwj6LkbPSUS1er1",
+  "tz1KfEsrtDaA1sX7vdM4qmEPWuSytuqCDp5j",
+  "tz1V4qCyvPKZ5UeqdH14HN42rxvNPQfc9UZg",
+  "tz1Lhf4J9Qxoe3DZ2nfe8FGDnvVj7oKjnMY6",
+  "tz1Ldzz6k1BHdhuKvAtMRX7h5kJSMHESMHLC",
+  "tz1Kf25fX1VdmYGSEzwFy1wNmkbSEZ2V83sY",
+  "tz1RCFbB9GpALpsZtu6J58sb74dm8qe6XBzv",
+  "tz1dbfppLAAxXZNtf2SDps7rch3qfUznKSoK",
+  "tz2FCNBrERXtaTtNX6iimR1UJ5JSDxvdHM93",
+  "tz1SohptP53wDPZhzTWzDUFAUcWF6DMBpaJV",
+  "tz1P2Po7YM526ughEsRbY4oR9zaUPDZjxFrb",
+  "tz1KzSC1J9aBxKp7u8TUnpN8L7S65PBRkgdF",
+  "tz1fJHFn6sWEd3NnBPngACuw2dggTv6nQZ7g",
+  "tz1NEKxGEHsFufk87CVZcrqWu8o22qh46GK6",
+  "tz1V3yg82mcrPJbegqVCPn6bC8w1CSTRp3f8",
+  "tz1aRoaRhSpRYvFdyvgWLL6TGyRoGF51wDjM",
+  "tz1MQJPGNMijnXnVoBENFz9rUhaPt3S7rWoz",
+  "tz1dRKU4FQ9QRRQPdaH4zCR6gmCmXfcvcgtB",
+  "tz1aDiEJf9ztRrAJEXZfcG3CKimoKsGhwVAi",
+];
+
+// we give no ordering preference. it's settled at module load time
+whitelist.sort(() => Math.random() - 0.5);
+
+const whiteListAddresses = [ledgerValidatorAddress, ...whitelist];
+
+export default whiteListAddresses;

package/src/api/index.ts

@@ -0,0 +1,2 @@
+export * from "./tzkt";
+export * from "./bakers";

package/src/api/tzkt.ts

@@ -0,0 +1,112 @@
+// @flow
+import network from "@ledgerhq/live-network/network";
+import URL from "url";
+import { getEnv } from "@ledgerhq/live-env";
+
+type APIAccount =
+  | {
+      type: "empty";
+      address: string;
+      counter: number;
+    }
+  | {
+      type: "user";
+      address: string;
+      publicKey: string;
+      revealed: boolean;
+      balance: number;
+      counter: number;
+      delegate?: {
+        alias: string;
+        address: string;
+        active: boolean;
+      };
+      delegationLevel: number;
+      delegationTime: string;
+      numTransactions: number;
+      firstActivityTime: string;
+    };
+
+type CommonOperationType = {
+  id: number;
+  hash?: string;
+  storageFee?: number;
+  allocationFee?: number;
+  bakerFee?: number;
+  timestamp: string;
+  level: number;
+  block: string;
+  gasLimit?: number;
+  storageLimit?: number;
+  status?: "applied" | "failed" | "backtracked" | "skipped";
+};
+
+export type APIOperation =
+  | (CommonOperationType & {
+      type: "transaction";
+      amount: number;
+      initiator: { address: string } | undefined | null;
+      sender: { address: string } | undefined | null;
+      target: { address: string } | undefined | null;
+    })
+  | (CommonOperationType & {
+      type: "reveal";
+    })
+  | (CommonOperationType & {
+      type: "delegation";
+      prevDelegate: { address: string } | undefined | null;
+      newDelegate: { address: string } | undefined | null;
+    })
+  | (CommonOperationType & {
+      type: "activation";
+      balance: number;
+    })
+  | (CommonOperationType & {
+      type: "origination";
+      contractBalance: number;
+      originatedContract: {
+        address: string;
+      };
+    })
+  | (CommonOperationType & {
+      type: "migration";
+      balanceChange: number;
+    })
+  | (CommonOperationType & {
+      type: ""; // this is to express fact we have others and we need to always filter out others
+    });
+
+const api = {
+  async getBlockCount(): Promise<number> {
+    const { data } = await network({
+      method: "GET",
+      url: `${getEnv("API_TEZOS_TZKT_API")}/v1/blocks/count`,
+    });
+    return data;
+  },
+  async getAccountByAddress(address: string): Promise<APIAccount> {
+    const { data } = await network({
+      method: "GET",
+      url: `${getEnv("API_TEZOS_TZKT_API")}/v1/accounts/${address}`,
+    });
+    return data;
+  },
+  async getAccountOperations(
+    address: string,
+    query: {
+      lastId?: number;
+      sort?: number;
+    },
+  ): Promise<APIOperation[]> {
+    const { data } = await network({
+      method: "GET",
+      url: URL.format({
+        pathname: `${getEnv("API_TEZOS_TZKT_API")}/v1/accounts/${address}/operations`,
+        query,
+      }),
+    });
+    return data;
+  },
+};
+
+export default api;

package/src/bridge/broadcast.test.ts

@@ -0,0 +1,30 @@
+import { SignedOperation } from "@ledgerhq/types-live";
+import { createFixtureOperation } from "../types/model.fixture";
+import broadcast from "./broadcast";
+
+const mockInjectOperation = jest.fn();
+jest.mock("@taquito/taquito", () => ({
+  TezosToolkit: jest.fn().mockReturnValue({
+    rpc: {
+      injectOperation: () => mockInjectOperation(),
+    },
+  }),
+}));
+
+describe("broadcast", () => {
+  it("calls 'injectOperation' from TezosToolkit and returns its hash computation", async () => {
+    // GIVEN
+    const signedOperation: SignedOperation = {
+      operation: createFixtureOperation(),
+      signature: "SIGNATURE",
+    };
+    mockInjectOperation.mockResolvedValue("SIGN_HASH");
+
+    // WHEN
+    const op = await broadcast({ signedOperation });
+
+    // THEN
+    expect(mockInjectOperation).toHaveBeenCalledTimes(1);
+    expect(op.hash).toEqual("SIGN_HASH");
+  });
+});

package/src/bridge/broadcast.ts

@@ -0,0 +1,18 @@
+import { TezosToolkit } from "@taquito/taquito";
+import { getEnv } from "@ledgerhq/live-env";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import { SignedOperation } from "@ledgerhq/types-live";
+
+const broadcast = async ({
+  signedOperation: { operation, signature },
+}: {
+  signedOperation: SignedOperation;
+}) => {
+  const tezos = new TezosToolkit(getEnv("API_TEZOS_NODE"));
+  const { rpc } = tezos;
+  const hash = await rpc.injectOperation(signature);
+
+  return patchOperationWithHash(operation, hash);
+};
+
+export default broadcast;