@ledgerhq/coin-evm 0.3.0 → 0.4.0-next.0

package/src/api/explorer/etherscan.ts

@@ -1,16 +1,27 @@
 import { delay } from "@ledgerhq/live-promise";
 import { Operation } from "@ledgerhq/types-live";
 import axios, { AxiosRequestConfig } from "axios";
-import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { makeLRUCache } from "@ledgerhq/live-network/cache";
-import { EtherscanERC20Event, EtherscanOperation } from "../../types";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { isNFTActive } from "@ledgerhq/coin-framework/nft/support";
 import { EtherscanAPIError } from "../../errors";
-import { etherscanERC20EventToOperation, etherscanOperationToOperation } from "../../adapters";
+import {
+  etherscanOperationToOperations,
+  etherscanERC20EventToOperations,
+  etherscanERC721EventToOperations,
+  etherscanERC1155EventToOperations,
+} from "../../adapters";
+import {
+  EtherscanERC1155Event,
+  EtherscanERC20Event,
+  EtherscanERC721Event,
+  EtherscanOperation,
+} from "../../types";
 
 export const ETHERSCAN_TIMEOUT = 5000; // 5 seconds between 2 calls
 export const DEFAULT_RETRIES_API = 8;
 
-async function fetchWithRetries<T>(
+export async function fetchWithRetries<T>(
   params: AxiosRequestConfig,
   retries = DEFAULT_RETRIES_API,
 ): Promise<T> {
@@ -43,67 +54,272 @@ async function fetchWithRetries<T>(
 /**
  * Get all the last "normal" transactions (no tokens / NFTs)
  */
-export const getLastCoinOperations = makeLRUCache<
-  [currency: CryptoCurrency, address: string, accountId: string, fromBlock: number],
-  Operation[]
->(
-  async (currency, address, accountId, fromBlock) => {
-    const apiDomain = currency.ethereumLikeInfo?.explorer?.uri;
-    if (!apiDomain) {
-      return [];
-    }
+export const getLastCoinOperations = async (
+  currency: CryptoCurrency,
+  address: string,
+  accountId: string,
+  fromBlock: number,
+  toBlock?: number,
+): Promise<Operation[]> => {
+  const apiDomain = currency.ethereumLikeInfo?.explorer?.uri;
+  if (!apiDomain) {
+    return [];
+  }
 
-    let url = `${apiDomain}/api?module=account&action=txlist&address=${address}&tag=latest&page=1&sort=desc`;
-    if (fromBlock) {
-      url += `&startBlock=${fromBlock}`;
-    }
+  let url = `${apiDomain}/api?module=account&action=txlist&address=${address}&tag=latest&page=1&sort=desc`;
+  if (fromBlock) {
+    url += `&startBlock=${fromBlock}`;
+  }
+  if (toBlock) {
+    url += `&endBlock=${toBlock}`;
+  }
 
-    const ops = await fetchWithRetries<EtherscanOperation[]>({
-      method: "GET",
-      url,
-    });
+  const ops = await fetchWithRetries<EtherscanOperation[]>({
+    method: "GET",
+    url,
+  });
 
-    return ops
-      .map(tx => etherscanOperationToOperation(accountId, tx))
-      .filter(Boolean) as Operation[];
-  },
-  (currency, address, accountId, fromBlock) => accountId + fromBlock,
-  { ttl: 5 * 1000 },
-);
+  return ops.map(tx => etherscanOperationToOperations(accountId, tx)).flat();
+};
 
 /**
  * Get all the last ERC20 transactions
  */
-export const getLastTokenOperations = makeLRUCache<
-  [currency: CryptoCurrency, address: string, accountId: string, fromBlock: number],
-  { tokenCurrency: TokenCurrency; operation: Operation }[]
->(
-  async (currency, address, accountId, fromBlock) => {
-    const apiDomain = currency.ethereumLikeInfo?.explorer?.uri;
-    if (!apiDomain) {
-      return [];
+export const getLastTokenOperations = async (
+  currency: CryptoCurrency,
+  address: string,
+  accountId: string,
+  fromBlock: number,
+  toBlock?: number,
+): Promise<Operation[]> => {
+  const apiDomain = currency.ethereumLikeInfo?.explorer?.uri;
+  if (!apiDomain) {
+    return [];
+  }
+
+  let url = `${apiDomain}/api?module=account&action=tokentx&address=${address}&tag=latest&page=1&sort=desc`;
+  if (fromBlock) {
+    url += `&startBlock=${fromBlock}`;
+  }
+  if (toBlock) {
+    url += `&endBlock=${toBlock}`;
+  }
+
+  const ops = await fetchWithRetries<EtherscanERC20Event[]>({
+    method: "GET",
+    url,
+  });
+
+  // Why this thing ?
+  // Multiple events can be fired by the same transactions and
+  // those transfer events can go from anyone to anyone, which
+  // means that multiple events could be sent to or from the
+  // same address during the same transaction.
+  //
+  // To make sure every event (transformed into an operation here)
+  // has a unique id, we're groupping them by transaction hash
+  // and using the index for each event fired.
+  const opsByHash: Record<string, EtherscanERC20Event[]> = {};
+  for (const op of ops) {
+    if (!opsByHash[op.hash]) {
+      opsByHash[op.hash] = [];
+    }
+    opsByHash[op.hash].push(op);
+  }
+
+  return Object.values(opsByHash)
+    .map(events =>
+      events.map((event, index) => etherscanERC20EventToOperations(accountId, event, index)),
+    )
+    .flat(2);
+};
+
+/**
+ * Get all the last ERC721 transactions
+ */
+export const getLastERC721Operations = async (
+  currency: CryptoCurrency,
+  address: string,
+  accountId: string,
+  fromBlock: number,
+  toBlock?: number,
+): Promise<Operation[]> => {
+  const apiDomain = currency.ethereumLikeInfo?.explorer?.uri;
+  if (!apiDomain) {
+    return [];
+  }
+
+  let url = `${apiDomain}/api?module=account&action=tokennfttx&address=${address}&tag=latest&page=1&sort=desc`;
+  if (fromBlock) {
+    url += `&startBlock=${fromBlock}`;
+  }
+  if (toBlock) {
+    url += `&endBlock=${toBlock}`;
+  }
+
+  const ops = await fetchWithRetries<EtherscanERC721Event[]>({
+    method: "GET",
+    url,
+  });
+
+  // Why this thing ?
+  // Multiple events can be fired by the same transactions and
+  // those transfer events can go from anyone to anyone, which
+  // means that multiple events could be sent to or from the
+  // same address during the same transaction.
+  //
+  // To make sure every event (transformed into an operation here)
+  // has a unique id, we're groupping them by transaction hash
+  // and using the index for each event fired.
+  const opsByHash: Record<string, EtherscanERC721Event[]> = {};
+  for (const op of ops) {
+    if (!opsByHash[op.hash]) {
+      opsByHash[op.hash] = [];
     }
+    opsByHash[op.hash].push(op);
+  }
+
+  return Object.values(opsByHash)
+    .map(events =>
+      events.map((event, index) => etherscanERC721EventToOperations(accountId, event, index)),
+    )
+    .flat(2);
+};
+
+/**
+ * Get all the last ERC71155 transactions
+ */
+export const getLastERC1155Operations = async (
+  currency: CryptoCurrency,
+  address: string,
+  accountId: string,
+  fromBlock: number,
+  toBlock?: number,
+): Promise<Operation[]> => {
+  const apiDomain = currency.ethereumLikeInfo?.explorer?.uri;
+  if (!apiDomain) {
+    return [];
+  }
 
-    let url = `${apiDomain}/api?module=account&action=tokentx&address=${address}&tag=latest&page=1&sort=desc`;
-    if (fromBlock) {
-      url += `&startBlock=${fromBlock}`;
+  let url = `${apiDomain}/api?module=account&action=token1155tx&address=${address}&tag=latest&page=1&sort=desc`;
+  if (fromBlock) {
+    url += `&startBlock=${fromBlock}`;
+  }
+  if (toBlock) {
+    url += `&endBlock=${toBlock}`;
+  }
+
+  const ops = await fetchWithRetries<EtherscanERC1155Event[]>({
+    method: "GET",
+    url,
+  });
+
+  // Why this thing ?
+  // Multiple events can be fired by the same transactions and
+  // those transfer events can go from anyone to anyone, which
+  // means that multiple events could be sent to or from the
+  // same address during the same transaction.
+  //
+  // To make sure every event (transformed into an operation here)
+  // has a unique id, we're groupping them by transaction hash
+  // and using the index for each event fired.
+  const opsByHash: Record<string, EtherscanERC1155Event[]> = {};
+  for (const op of ops) {
+    if (!opsByHash[op.hash]) {
+      opsByHash[op.hash] = [];
     }
+    opsByHash[op.hash].push(op);
+  }
+
+  return Object.values(opsByHash)
+    .map(events =>
+      events.map((event, index) => etherscanERC1155EventToOperations(accountId, event, index)),
+    )
+    .flat(2);
+};
+
+/**
+ * Get all NFT related operations (ERC721 + ERC1155)
+ */
+export const getLastNftOperations = async (
+  currency: CryptoCurrency,
+  address: string,
+  accountId: string,
+  fromBlock: number,
+  toBlock?: number,
+): Promise<Operation[]> => {
+  const erc721Ops = await getLastERC721Operations(currency, address, accountId, fromBlock, toBlock);
+  const erc1155Ops = await getLastERC1155Operations(
+    currency,
+    address,
+    accountId,
+    fromBlock,
+    toBlock,
+  );
+
+  return [...erc721Ops, ...erc1155Ops].sort(
+    // sorting DESC order
+    (a, b) => b.date.getTime() - a.date.getTime(),
+  );
+};
+
+/**
+ * Wrapper around all operation types' requests
+ *
+ * ⚠ The lack of parallelization is on purpose,
+ * do not use a Promise.all here, it would
+ * break because of the rate limits
+ */
+export const getLastOperations = makeLRUCache<
+  [
+    currency: CryptoCurrency,
+    address: string,
+    accountId: string,
+    fromBlock: number,
+    toBlock?: number,
+  ],
+  {
+    lastCoinOperations: Operation[];
+    lastTokenOperations: Operation[];
+    lastNftOperations: Operation[];
+  }
+>(
+  async (currency, address, accountId, fromBlock, toBlock) => {
+    const lastCoinOperations = await getLastCoinOperations(
+      currency,
+      address,
+      accountId,
+      fromBlock,
+      toBlock,
+    );
+
+    const lastTokenOperations = await getLastTokenOperations(
+      currency,
+      address,
+      accountId,
+      fromBlock,
+      toBlock,
+    );
 
-    const ops = await fetchWithRetries<EtherscanERC20Event[]>({
-      method: "GET",
-      url,
-    });
+    const lastNftOperations = isNFTActive(currency)
+      ? await getLastNftOperations(currency, address, accountId, fromBlock, toBlock)
+      : [];
 
-    return ops.map(event => etherscanERC20EventToOperation(accountId, event)).filter(Boolean) as {
-      tokenCurrency: TokenCurrency;
-      operation: Operation;
-    }[];
+    return {
+      lastCoinOperations,
+      lastTokenOperations,
+      lastNftOperations,
+    };
   },
-  (currency, address, accountId, fromBlock) => accountId + fromBlock,
-  { ttl: 5 * 1000 },
+  (currency, address, accountId, fromBlock, toBlock) => accountId + fromBlock + toBlock,
+  { ttl: ETHERSCAN_TIMEOUT },
 );
 
 export default {
   getLastCoinOperations,
   getLastTokenOperations,
+  getLastERC721Operations,
+  getLastERC1155Operations,
+  getLastNftOperations,
+  getLastOperations,
 };

package/src/api/explorer/index.ts

@@ -1,20 +1,34 @@
 import { CacheRes } from "@ledgerhq/live-network/cache";
-import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import { Operation } from "@ledgerhq/types-live";
 import etherscanLikeApi from "./etherscan";
 
+type ExplorerBasicRequest = (
+  currency: CryptoCurrency,
+  address: string,
+  accountId: string,
+  fromBlock: number,
+  toBlock?: number,
+) => Promise<Operation[]>;
+
 type ExplorerApi = {
-  getLastCoinOperations: CacheRes<
-    [currency: CryptoCurrency, address: string, accountId: string, fromBlock: number],
-    Operation[]
-  >;
-  getLastTokenOperations: CacheRes<
-    [currency: CryptoCurrency, address: string, accountId: string, fromBlock: number],
+  getLastOperations: CacheRes<
+    Parameters<ExplorerBasicRequest>,
     {
-      tokenCurrency: TokenCurrency;
-      operation: Operation;
-    }[]
+      lastCoinOperations: Operation[];
+      lastTokenOperations: Operation[];
+      lastNftOperations: Operation[];
+    }
   >;
+  // For now every other exported function should be considered as internal
+  // methods as they're unecessary to the synchronization it self.
+  // This can be updated with new sync requirements.
+  // & { [key in
+  //   | "getLastCoinOperations"
+  //   | "getLastTokenOperations"
+  //   | "getLastERC721Operations"
+  //   | "getLastERC1155Operations"
+  //   | "getLastNftOperations"]: ExplorerBasicRequest; }
 };
 
 /**

package/src/api/nft/index.ts

@@ -0,0 +1,49 @@
+import { getEnv } from "@ledgerhq/live-env";
+import network from "@ledgerhq/live-network/network";
+import { NFTCollectionMetadataResponse, NFTMetadataResponse } from "@ledgerhq/types-live";
+import { CollectionMetadataInput, NftMetadataInput } from "@ledgerhq/coin-framework/nft/types";
+
+/**
+ * Batched request of nft metadata on the "ethereum" protocol
+ *
+ * ⚠️ ethereum protocol doesn't mean ethereum chain, you can see this
+ * as the evm protocol instead, and you can specify a chainId
+ * to request the metadata on any evm chain supported
+ */
+export const getNftMetadata = async (
+  input: NftMetadataInput[],
+  chainId: number,
+): Promise<NFTMetadataResponse[]> => {
+  const { data }: { data: NFTMetadataResponse[] } = await network({
+    method: "POST",
+    url: `${getEnv("NFT_ETH_METADATA_SERVICE")}/v1/ethereum/${chainId}/contracts/tokens/infos`,
+    data: input,
+  });
+
+  return data;
+};
+
+/**
+ * Batched request of nft collection metadata on the "ethereum" protocol
+ *
+ * ⚠️ ethereum protocol doesn't mean ethereum chain, you can see this
+ * as the evm protocol instead, and you can specify a chainId
+ * to request the metadata on any evm chain supported
+ */
+export const getNftCollectionMetadata = async (
+  input: CollectionMetadataInput[],
+  chainId: number,
+): Promise<NFTCollectionMetadataResponse[]> => {
+  const { data }: { data: NFTCollectionMetadataResponse[] } = await network({
+    method: "POST",
+    url: `${getEnv("NFT_ETH_METADATA_SERVICE")}/v1/ethereum/${chainId}/contracts/infos`,
+    data: input,
+  });
+
+  return data;
+};
+
+export default {
+  getNftMetadata,
+  getNftCollectionMetadata,
+};

package/src/api/rpc/index.native.ts

@@ -1,3 +1,5 @@
+/* istanbul ignore file: pure exports, test unecessary */
+
 /** ⚠️ keep this order of import. @see https://docs.ethers.io/v5/cookbook/react-native/#cookbook-reactnative ⚠️ */
 import "react-native-get-random-values";
 import "@ethersproject/shims";

package/src/api/rpc/rpc.common.ts

@@ -13,8 +13,8 @@ import { transactionToEthersTransaction } from "../../adapters";
 import { getSerializedTransaction } from "../../transaction";
 import ERC20Abi from "../../abis/erc20.abi.json";
 
-export const RPC_TIMEOUT = 5000; // wait 5 sec after a fail
-export const DEFAULT_RETRIES_RPC_METHODS = 3;
+export const RPC_TIMEOUT = process.env.NODE_ENV === "test" ? 100 : 5000; // wait 5 sec after a fail
+export const DEFAULT_RETRIES_RPC_METHODS = process.env.NODE_ENV === "test" ? 1 : 3;
 
 /**
  * Cache for RPC providers to avoid recreating the connection on every usage of `withApi`
@@ -119,7 +119,7 @@ export const getTokenBalance = (
  */
 export const getTransactionCount = (currency: CryptoCurrency, addr: string): Promise<number> =>
   withApi(currency, async api => {
-    return api.getTransactionCount(addr);
+    return api.getTransactionCount(addr, "pending");
   });
 
 /**

package/src/bridge/js.ts

@@ -1,28 +1,24 @@
-import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+/* istanbul ignore file: pure exports, bridge tested by live-common with bridge.integration.test.ts */
 import {
+  defaultUpdateTransaction,
   makeAccountBridgeReceive,
   makeScanAccounts,
 } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
-import { broadcast } from "../broadcast";
-import { createTransaction } from "../createTransaction";
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import type { Transaction as EvmTransaction, Transaction } from "../types";
+import { EvmAddress, EvmSignature, EvmSigner } from "../signer";
 import { estimateMaxSpendable } from "../estimateMaxSpendable";
 import { getTransactionStatus } from "../getTransactionStatus";
-import resolver from "../hw-getAddress";
-import { hydrate, preload } from "../preload";
+import { getAccountShape, sync } from "../synchronization";
 import { prepareTransaction } from "../prepareTransaction";
+import { createTransaction } from "../createTransaction";
 import { buildSignOperation } from "../signOperation";
-import { getAccountShape, sync } from "../synchronization";
-import { EvmAddress, EvmSignature, EvmSigner } from "../signer";
-import type { Transaction as EvmTransaction, Transaction } from "../types";
-
-const updateTransaction: AccountBridge<EvmTransaction>["updateTransaction"] = (
-  transaction,
-  patch,
-) => {
-  return { ...transaction, ...patch } as EvmTransaction;
-};
+import { hydrate, preload } from "../preload";
+import nftResolvers from "../nftResolvers";
+import { broadcast } from "../broadcast";
+import resolver from "../hw-getAddress";
 
 export function buildCurrencyBridge(
   signerContext: SignerContext<EvmSigner, EvmAddress | EvmSignature>,
@@ -38,6 +34,7 @@ export function buildCurrencyBridge(
     preload,
     hydrate,
     scanAccounts,
+    nftResolvers,
   };
 }
 
@@ -51,7 +48,7 @@ export function buildAccountBridge(
 
   return {
     createTransaction,
-    updateTransaction,
+    updateTransaction: defaultUpdateTransaction<EvmTransaction>,
     prepareTransaction,
     getTransactionStatus,
     sync,

package/src/broadcast.ts

@@ -1,7 +1,12 @@
-import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import {
+  encodeERC1155OperationId,
+  encodeERC721OperationId,
+} from "@ledgerhq/coin-framework/nft/nftOperationId";
+import { encodeNftId } from "@ledgerhq/coin-framework/nft/nftId";
 import type { AccountBridge, Operation } from "@ledgerhq/types-live";
-import { broadcastTransaction } from "./api/rpc";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import { Transaction as EvmTransaction } from "./types";
+import { broadcastTransaction } from "./api/rpc";
 
 /**
  * Broadcast a transaction and update the operation linked
@@ -30,6 +35,28 @@ export const broadcast: AccountBridge<EvmTransaction>["broadcast"] = async ({
         blockHash: txResponse.blockHash,
         date: new Date(txResponse.timestamp ? txResponse.timestamp * 1000 : Date.now()),
       })) || [],
+    nftOperations:
+      operation.nftOperations?.map(nftOp => {
+        const nftId = encodeNftId(
+          nftOp.accountId,
+          nftOp.contract || "",
+          nftOp.tokenId || "",
+          account.currency.id,
+        );
+
+        return {
+          ...nftOp,
+          id:
+            nftOp.standard === "ERC721"
+              ? encodeERC721OperationId(nftId, txResponse.hash, nftOp.type, 0)
+              : encodeERC1155OperationId(nftId, txResponse.hash, nftOp.type, 0),
+          hash: txResponse.hash,
+          blockNumber: txResponse.blockNumber,
+          blockHeight: txResponse.blockNumber,
+          blockHash: txResponse.blockHash,
+          date: new Date(txResponse.timestamp ? txResponse.timestamp * 1000 : Date.now()),
+        };
+      }) || [],
   } as Operation;
 };
 

package/src/buildOptimisticOperation.ts

@@ -1,10 +1,15 @@
-import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
-import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import { Account, Operation, OperationType, TokenAccount } from "@ledgerhq/types-live";
-import BigNumber from "bignumber.js";
 import eip55 from "eip55";
-import { getEstimatedFees } from "./logic";
-import { Transaction as EvmTransaction } from "./types";
+import BigNumber from "bignumber.js";
+import { Account, Operation, OperationType, TokenAccount } from "@ledgerhq/types-live";
+import {
+  encodeERC1155OperationId,
+  encodeERC721OperationId,
+} from "@ledgerhq/coin-framework/nft/nftOperationId";
+import { encodeNftId } from "@ledgerhq/coin-framework/nft/nftId";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
+import { EvmNftTransaction, Transaction as EvmTransaction } from "./types";
+import { getEstimatedFees, isNftTransaction } from "./logic";
 
 /**
  * Build an optimistic operation for the coin of the integration (e.g. Ether for Ethereum)
@@ -85,6 +90,62 @@ export const buildOptimisticTokenOperation = (
   return operation;
 };
 
+/**
+ * Build an optimistic operation for an ERC721 or ERC1155 transaction
+ */
+export const buildOptimisticNftOperation = (
+  account: Account,
+  transaction: EvmNftTransaction & EvmTransaction,
+): Operation => {
+  const type = "NFT_OUT";
+  const estimatedFees = getEstimatedFees(transaction);
+  const { nft } = transaction;
+  const value = nft.quantity;
+
+  const coinOperation = buildOptimisticCoinOperation(
+    account,
+    {
+      ...transaction,
+      recipient: nft.contract,
+      amount: new BigNumber(0),
+    },
+    "FEES",
+  );
+
+  const nftId = encodeNftId(account.id, nft.contract, nft.tokenId, account.currency.id);
+  const nftOpId =
+    transaction.mode === "erc721"
+      ? encodeERC721OperationId(nftId, "", type, 0)
+      : encodeERC1155OperationId(nftId, "", type, 0);
+
+  // keys marked with a <-- will be updated by the broadcast method
+  const operation: Operation = {
+    ...coinOperation,
+    nftOperations: [
+      {
+        id: nftOpId, // <--
+        hash: "", // <--
+        type,
+        value,
+        fee: estimatedFees,
+        blockHash: null, // <--
+        blockHeight: null, // <--
+        senders: [eip55.encode(account.freshAddress)],
+        recipients: [eip55.encode(transaction.recipient)],
+        accountId: account.id,
+        transactionSequenceNumber: transaction.nonce,
+        date: new Date(), // <--
+        extra: {},
+        contract: nft.contract,
+        standard: transaction.mode.toUpperCase(),
+        tokenId: nft.tokenId,
+      },
+    ],
+  };
+
+  return operation;
+};
+
 /**
  * Create a temporary operation to use until it's confirmed by the blockchain
  */
@@ -92,6 +153,10 @@ export const buildOptimisticOperation = (
   account: Account,
   transaction: EvmTransaction,
 ): Operation => {
+  if (isNftTransaction(transaction)) {
+    return buildOptimisticNftOperation(account, transaction);
+  }
+
   const subAccount = findSubAccountById(account, transaction?.subAccountId || "");
   const isTokenTransaction = subAccount?.type === "TokenAccount";
 

package/src/cli-transaction.ts

@@ -1,3 +1,5 @@
+/* istanbul ignore file: untested because empty */
+
 // Needed by sync-families-dispatch script
 // libs/ledger-live-common/scripts/sync-families-dispatch.mjs
 export default function makeCliTools() {