@ledgerhq/coin-evm 2.28.0-nightly.3 → 2.28.0

package/src/adapters/etherscan.ts

@@ -6,6 +6,7 @@ import {
 } from "@ledgerhq/coin-framework/nft/nftOperationId";
 import { Operation, OperationType } from "@ledgerhq/types-live";
 import { encodeNftId } from "@ledgerhq/coin-framework/nft/nftId";
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
 import { decodeAccountId, encodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
 import { encodeOperationId, encodeSubOperationId } from "@ledgerhq/coin-framework/operation";
 import {
@@ -16,7 +17,6 @@ import {
   EtherscanInternalTransaction,
 } from "../types";
 import { safeEncodeEIP55 } from "../utils";
-import { getCryptoAssetsStore } from "../cryptoAssetsStore";
 
 /**
  * Adapter to convert an Etherscan operation into Ledger Live Operations.
@@ -82,10 +82,7 @@ export const etherscanERC20EventToOperations = (
   index = 0,
 ): Operation[] => {
   const { currencyId, xpubOrAddress: address } = decodeAccountId(accountId);
-  const tokenCurrency = getCryptoAssetsStore().findTokenByAddressInCurrency(
-    event.contractAddress,
-    currencyId,
-  );
+  const tokenCurrency = findTokenByAddressInCurrency(event.contractAddress, currencyId);
   if (!tokenCurrency) return [];
 
   const tokenAccountId = encodeTokenAccountId(accountId, tokenCurrency);

package/src/adapters/ledger.ts

@@ -6,6 +6,7 @@ import {
 } from "@ledgerhq/coin-framework/nft/nftOperationId";
 import { Operation, OperationType } from "@ledgerhq/types-live";
 import { encodeNftId } from "@ledgerhq/coin-framework/nft/nftId";
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
 import { decodeAccountId, encodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
 import { encodeOperationId, encodeSubOperationId } from "@ledgerhq/coin-framework/operation";
 import {
@@ -16,7 +17,6 @@ import {
   LedgerExplorerInternalTransaction,
 } from "../types";
 import { safeEncodeEIP55 } from "../utils";
-import { getCryptoAssetsStore } from "../cryptoAssetsStore";
 
 /**
  * Adapter to convert a Ledger Explorer operation
@@ -82,10 +82,7 @@ export const ledgerERC20EventToOperations = (
   const { accountId, hash, fee, blockHeight, blockHash, transactionSequenceNumber, date } =
     coinOperation;
   const { currencyId, xpubOrAddress: address } = decodeAccountId(accountId);
-  const tokenCurrency = getCryptoAssetsStore().findTokenByAddressInCurrency(
-    event.contract,
-    currencyId,
-  );
+  const tokenCurrency = findTokenByAddressInCurrency(event.contract, currencyId);
   if (!tokenCurrency) return [];
 
   const tokenAccountId = encodeTokenAccountId(accountId, tokenCurrency);

package/src/api/index.ts

@@ -27,7 +27,6 @@ import {
   listOperations,
   getBalance,
   getSequence,
-  validateIntent,
 } from "../logic/index";
 
 export function createApi(config: EvmConfig, currencyId: CryptoCurrencyId): Api {
@@ -44,7 +43,8 @@ export function createApi(config: EvmConfig, currencyId: CryptoCurrencyId): Api
     ): Promise<string> => craftTransaction(currency, { transactionIntent, customFees }),
     estimateFees: (
       transactionIntent: TransactionIntent<MemoNotSupported>,
-    ): Promise<FeeEstimation> => estimateFees(currency, transactionIntent),
+      customFees?: FeeEstimation,
+    ): Promise<FeeEstimation> => estimateFees(currency, transactionIntent, customFees),
     getBalance: (address: string): Promise<Balance[]> => getBalance(currency, address),
     lastBlock: (): Promise<BlockInfo> => lastBlock(currency),
     listOperations: (
@@ -65,7 +65,8 @@ export function createApi(config: EvmConfig, currencyId: CryptoCurrencyId): Api
       throw new Error("getRewards is not supported");
     },
     getSequence: (address: string): Promise<number> => getSequence(currency, address),
-    validateIntent: (intent: TransactionIntent): Promise<TransactionValidation> =>
-      validateIntent(currency, intent),
+    validateIntent(_intent: TransactionIntent): Promise<TransactionValidation> {
+      throw new Error("validateIntent is not supported");
+    },
   };
 }

package/src/bridge/js.ts

@@ -8,12 +8,10 @@ import {
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import type { AccountBridge, Bridge, CurrencyBridge } from "@ledgerhq/types-live";
 import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
-import type { CryptoAssetsStoreGetter } from "@ledgerhq/types-live";
 import type { Transaction as EvmTransaction } from "../types/index";
 import { setCoinConfig, type CoinConfig } from "../config";
 import type { EvmSigner } from "../types/signer";
 import resolver from "../hw-getAddress";
-import { setCryptoAssetsStoreGetter } from "../cryptoAssetsStore";
 import { estimateMaxSpendable } from "./estimateMaxSpendable";
 import { getTransactionStatus } from "./getTransactionStatus";
 import { getAccountShape, sync } from "./synchronization";
@@ -68,10 +66,8 @@ export function buildAccountBridge(
 export function createBridges(
   signerContext: SignerContext<EvmSigner>,
   coinConfig: CoinConfig,
-  cryptoAssetsStoreGetter: CryptoAssetsStoreGetter,
 ): Bridge<EvmTransaction> {
   setCoinConfig(coinConfig);
-  setCryptoAssetsStoreGetter(cryptoAssetsStoreGetter);
 
   return {
     currencyBridge: buildCurrencyBridge(signerContext),

package/src/bridge/preload.ts

@@ -10,11 +10,6 @@ import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import { fetchTokensFromCALService } from "@ledgerhq/cryptoassets/crypto-assets-importer/fetch/index";
 import { getCALHash, setCALHash } from "../logic";
 
-let shouldSkipTokenLoading = false;
-export function setShouldSkipTokenLoading(skip: boolean): void {
-  shouldSkipTokenLoading = skip;
-}
-
 export const fetchERC20Tokens: (
   currency: CryptoCurrency,
 ) => Promise<ERC20Token[] | null> = async currency => {
@@ -83,8 +78,6 @@ export const fetchERC20Tokens: (
 };
 
 export async function preload(currency: CryptoCurrency): Promise<ERC20Token[] | undefined> {
-  if (shouldSkipTokenLoading) return;
-
   const erc20 = await fetchERC20Tokens(currency);
   if (!erc20) return;
 
@@ -94,7 +87,6 @@ export async function preload(currency: CryptoCurrency): Promise<ERC20Token[] |
 }
 
 export function hydrate(value: unknown, currency: CryptoCurrency): void {
-  if (shouldSkipTokenLoading) return;
   if (!Array.isArray(value)) {
     const { chainId } = currency.ethereumLikeInfo || {};
     const tokens = tokensByChainId[chainId as keyof typeof tokensByChainId] || [];

package/src/deviceTransactionConfig.ts

@@ -6,12 +6,12 @@ import {
   ERC1155_CLEAR_SIGNED_SELECTORS,
 } from "@ledgerhq/evm-tools/selectors/index";
 import { Account, AccountLike } from "@ledgerhq/types-live";
+import { findTokenByAddress } from "@ledgerhq/cryptoassets/tokens";
 import { validateDomain } from "@ledgerhq/domain-service/utils/index";
 import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
 import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
 import type { CommonDeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
 import { Transaction as EvmTransaction, TransactionStatus } from "./types";
-import { getCryptoAssetsStore } from "./cryptoAssetsStore";
 
 type DeviceTransactionField = CommonDeviceTransactionField;
 
@@ -29,8 +29,7 @@ const inferDeviceTransactionConfigWalletApi = (
   const knownNft = mainAccount.nfts?.find(
     nft => nft.contract.toLowerCase() === transaction.recipient.toLowerCase(),
   );
-
-  const token = getCryptoAssetsStore().findTokenByAddress(transaction.recipient);
+  const token = findTokenByAddress(transaction.recipient);
 
   // ERC20 fields
   if (token && Object.values<string>(ERC20_CLEAR_SIGNED_SELECTORS).includes(selector)) {

package/src/logic/common.ts

@@ -1,58 +1,6 @@
 import { ethers } from "ethers";
 import { TransactionTypes } from "ethers/lib/utils";
-import { FeeEstimation } from "@ledgerhq/coin-framework/api/types";
 import ERC20ABI from "../abis/erc20.abi.json";
-import { ApiFeeData, ApiGasOptions } from "../types";
-
-export function isApiGasOptions(options: unknown): options is ApiGasOptions {
-  if (!options || typeof options !== "object") return false;
-
-  return (
-    "slow" in options &&
-    isApiFeeData(options.slow) &&
-    "medium" in options &&
-    isApiFeeData(options.medium) &&
-    "fast" in options &&
-    isApiFeeData(options.fast)
-  );
-}
-
-export function isApiFeeData(fees: unknown): fees is ApiFeeData {
-  if (!fees || typeof fees !== "object") return false;
-
-  const isBigIntOrNull = (value: unknown): boolean => value === null || typeof value === "bigint";
-
-  return (
-    "maxFeePerGas" in fees &&
-    isBigIntOrNull(fees.maxFeePerGas) &&
-    "maxPriorityFeePerGas" in fees &&
-    isBigIntOrNull(fees.maxPriorityFeePerGas) &&
-    "gasPrice" in fees &&
-    isBigIntOrNull(fees.gasPrice) &&
-    "nextBaseFee" in fees &&
-    isBigIntOrNull(fees.nextBaseFee)
-  );
-}
-
-type LegacyFeeEstimation = FeeEstimation & { parameters: { gasPrice: bigint } };
-type Eip1559FeeEstimation = FeeEstimation & {
-  parameters: { maxFeePerGas: bigint; maxPriorityFeePerGas: bigint };
-};
-
-export function isLegacyFeeEstimation(
-  estimation: FeeEstimation,
-): estimation is LegacyFeeEstimation {
-  return typeof estimation.parameters?.gasPrice === "bigint";
-}
-
-export function isEip1559FeeEstimation(
-  estimation: FeeEstimation,
-): estimation is Eip1559FeeEstimation {
-  return (
-    typeof estimation.parameters?.maxFeePerGas === "bigint" &&
-    typeof estimation.parameters?.maxPriorityFeePerGas === "bigint"
-  );
-}
 
 export function getTransactionType(intentType: string): TransactionTypes {
   if (!["send-legacy", "send-eip1559"].includes(intentType)) {

package/src/logic/estimateFees.test.ts

@@ -7,8 +7,6 @@ import type {
 } from "@ledgerhq/coin-framework/api/index";
 import { getNodeApi } from "../network/node";
 import { FeeData } from "../types";
-import ledgerGasTracker from "../network/gasTracker/ledger";
-import { EvmCoinConfig, setCoinConfig } from "../config";
 import { estimateFees } from "./estimateFees";
 
 jest.mock("../network/node", () => ({ getNodeApi: jest.fn() }));
@@ -48,39 +46,9 @@ describe("estimateFees", () => {
     mockNodeApi.getGasEstimation.mockResolvedValue(mockGasLimit);
     mockNodeApi.getFeeData.mockResolvedValue(mockFeeData);
     jest.mocked(getNodeApi).mockReturnValue(mockNodeApi as any);
-
-    setCoinConfig(
-      () =>
-        ({
-          info: {
-            gasTracker: { type: "ledger", explorerId: "eth" },
-          },
-        }) as unknown as EvmCoinConfig,
-    );
   });
 
   it("should estimate fees for native asset", async () => {
-    jest.spyOn(ledgerGasTracker, "getGasOptions").mockResolvedValue({
-      fast: {
-        maxFeePerGas: new BigNumber("30000000000"),
-        maxPriorityFeePerGas: new BigNumber("3000000000"),
-        gasPrice: new BigNumber("30000000000"),
-        nextBaseFee: null,
-      },
-      medium: {
-        maxFeePerGas: new BigNumber("20000000000"),
-        maxPriorityFeePerGas: new BigNumber("2000000000"),
-        gasPrice: new BigNumber("20000000000"),
-        nextBaseFee: null,
-      },
-      slow: {
-        maxFeePerGas: new BigNumber("10000000000"),
-        maxPriorityFeePerGas: new BigNumber("1000000000"),
-        gasPrice: new BigNumber("10000000000"),
-        nextBaseFee: null,
-      },
-    });
-
     const result = await estimateFees(mockCurrency, mockIntent);
 
     expect(mockNodeApi.getFeeData).toHaveBeenCalledWith(mockCurrency, {
@@ -88,33 +56,12 @@ describe("estimateFees", () => {
       type: 0,
     });
     expect(result).toEqual({
-      value: 420000000000000n,
+      value: BigInt(mockGasLimit.multipliedBy(mockFeeData.gasPrice!).toFixed()),
       parameters: {
         gasPrice: 20000000000n,
         maxFeePerGas: 20000000000n,
         maxPriorityFeePerGas: 2000000000n,
         nextBaseFee: null,
-        gasLimit: 21000n,
-        gasOptions: {
-          fast: {
-            maxFeePerGas: 30000000000n,
-            maxPriorityFeePerGas: 3000000000n,
-            gasPrice: 30000000000n,
-            nextBaseFee: null,
-          },
-          medium: {
-            gasPrice: 20000000000n,
-            maxFeePerGas: 20000000000n,
-            maxPriorityFeePerGas: 2000000000n,
-            nextBaseFee: null,
-          },
-          slow: {
-            gasPrice: 10000000000n,
-            maxFeePerGas: 10000000000n,
-            maxPriorityFeePerGas: 1000000000n,
-            nextBaseFee: null,
-          },
-        },
       },
     });
   });
@@ -128,33 +75,12 @@ describe("estimateFees", () => {
       type: 0,
     });
     expect(result).toEqual({
-      value: 420000000000000n,
+      value: BigInt(mockGasLimit.multipliedBy(mockFeeData.gasPrice!).toFixed()),
       parameters: {
         gasPrice: 20000000000n,
         maxFeePerGas: 20000000000n,
         maxPriorityFeePerGas: 2000000000n,
         nextBaseFee: null,
-        gasLimit: 21000n,
-        gasOptions: {
-          fast: {
-            maxFeePerGas: 30000000000n,
-            maxPriorityFeePerGas: 3000000000n,
-            gasPrice: 30000000000n,
-            nextBaseFee: null,
-          },
-          medium: {
-            gasPrice: 20000000000n,
-            maxFeePerGas: 20000000000n,
-            maxPriorityFeePerGas: 2000000000n,
-            nextBaseFee: null,
-          },
-          slow: {
-            gasPrice: 10000000000n,
-            maxFeePerGas: 10000000000n,
-            maxPriorityFeePerGas: 1000000000n,
-            nextBaseFee: null,
-          },
-        },
       },
     });
   });
@@ -164,34 +90,67 @@ describe("estimateFees", () => {
 
     const result = await estimateFees(mockCurrency, mockIntent);
     expect(result).toEqual({
-      value: 0n,
+      value: BigInt(0),
       parameters: {
         gasPrice: null,
         maxFeePerGas: 20000000000n,
         maxPriorityFeePerGas: 2000000000n,
         nextBaseFee: null,
-        gasLimit: 21000n,
-        gasOptions: {
-          fast: {
-            maxFeePerGas: 30000000000n,
-            maxPriorityFeePerGas: 3000000000n,
-            gasPrice: 30000000000n,
-            nextBaseFee: null,
-          },
-          medium: {
-            gasPrice: 20000000000n,
-            maxFeePerGas: 20000000000n,
-            maxPriorityFeePerGas: 2000000000n,
-            nextBaseFee: null,
-          },
-          slow: {
-            gasPrice: 10000000000n,
-            maxFeePerGas: 10000000000n,
-            maxPriorityFeePerGas: 1000000000n,
-            nextBaseFee: null,
-          },
-        },
       },
     });
   });
+
+  it.each([
+    [
+      "legacy",
+      {
+        value: 8n,
+        parameters: {
+          gasPrice: 5n,
+        },
+      },
+    ],
+    [
+      "eip1559",
+      {
+        value: 8n,
+        parameters: {
+          maxFeePerGas: 2n,
+          maxPriorityFeePerGas: 3n,
+        },
+      },
+    ],
+  ])("uses the given fees for a %s transaction type", async (type, customFees) => {
+    const getFeeData = jest.spyOn(mockNodeApi, "getFeeData");
+    const getGasEstimation = jest.spyOn(mockNodeApi, "getGasEstimation");
+
+    expect(
+      await estimateFees(
+        {} as CryptoCurrency,
+        { type: `send-${type}` } as unknown as TransactionIntent,
+        customFees,
+      ),
+    ).toEqual(customFees);
+    expect(getFeeData).not.toHaveBeenCalled();
+    expect(getGasEstimation).not.toHaveBeenCalled();
+  });
+
+  it("ignores malformed or irrelevant custom fees", async () => {
+    const getFeeData = jest.spyOn(mockNodeApi, "getFeeData");
+    const getGasEstimation = jest.spyOn(mockNodeApi, "getGasEstimation");
+
+    expect(
+      await estimateFees(
+        {} as CryptoCurrency,
+        {
+          type: "send-eip1559",
+          amount: 3n,
+          asset: { type: "native" },
+        } as unknown as TransactionIntent,
+        { value: 8n, parameters: { gasPrice: 5n } },
+      ),
+    ).not.toEqual({ value: 8n, parameters: { gasPrice: 5n } });
+    expect(getFeeData).toHaveBeenCalled();
+    expect(getGasEstimation).toHaveBeenCalled();
+  });
 });

package/src/logic/estimateFees.ts

@@ -7,37 +7,29 @@ import type {
 } from "@ledgerhq/coin-framework/api/index";
 import { TransactionTypes } from "ethers/lib/utils";
 import { getNodeApi } from "../network/node";
-import { ApiFeeData, ApiGasOptions, FeeData, GasOptions, isNative } from "../types";
-import { getGasTracker } from "../network/gasTracker";
+import { isNative } from "../types";
 import { getErc20Data, getTransactionType } from "./common";
 
-function toApiFeeData(feeData: FeeData): ApiFeeData {
-  return {
-    gasPrice: feeData.gasPrice && BigInt(feeData.gasPrice.toFixed()),
-    maxFeePerGas: feeData.maxFeePerGas && BigInt(feeData.maxFeePerGas.toFixed()),
-    maxPriorityFeePerGas:
-      feeData.maxPriorityFeePerGas && BigInt(feeData.maxPriorityFeePerGas.toFixed()),
-    nextBaseFee: feeData.nextBaseFee && BigInt(feeData.nextBaseFee.toFixed()),
-  };
-}
-
-function toApiGasOptions(options: GasOptions): ApiGasOptions {
-  return {
-    fast: toApiFeeData(options.fast),
-    medium: toApiFeeData(options.medium),
-    slow: toApiFeeData(options.slow),
-  };
-}
-
 export async function estimateFees(
   currency: CryptoCurrency,
   transactionIntent: TransactionIntent<MemoNotSupported>,
+  customFees?: FeeEstimation,
 ): Promise<FeeEstimation> {
   const { amount, asset, recipient, sender, type } = transactionIntent;
 
   const transactionType = getTransactionType(type);
+
+  if (
+    (transactionType === TransactionTypes.legacy &&
+      typeof customFees?.parameters?.gasPrice === "bigint") ||
+    (transactionType === TransactionTypes.eip1559 &&
+      typeof customFees?.parameters?.maxFeePerGas === "bigint" &&
+      typeof customFees?.parameters?.maxPriorityFeePerGas === "bigint")
+  ) {
+    return customFees;
+  }
+
   const node = getNodeApi(currency);
-  const gasTracker = getGasTracker(currency);
   const to = isNative(asset) ? recipient : (asset.assetReference as string);
   const data = isNative(asset) ? Buffer.from([]) : getErc20Data(recipient, amount);
   const value = isNative(asset) ? amount : 0n;
@@ -49,10 +41,6 @@ export async function estimateFees(
     type: transactionType,
     feesStrategy: transactionIntent.feesStrategy,
   });
-  const gasOptions = await gasTracker?.getGasOptions({
-    currency,
-    options: { useEIP1559: transactionType === TransactionTypes.eip1559 },
-  });
   const gasPrice =
     transactionType === TransactionTypes.legacy ? feeData.gasPrice : feeData.maxFeePerGas;
   const fee = gasPrice?.multipliedBy(gasLimit) || new BigNumber(0);
@@ -60,9 +48,11 @@ export async function estimateFees(
   return {
     value: BigInt(fee.toString()),
     parameters: {
-      ...toApiFeeData(feeData),
-      gasLimit: BigInt(gasLimit.toFixed()),
-      gasOptions: gasOptions && toApiGasOptions(gasOptions),
+      gasPrice: feeData.gasPrice && BigInt(feeData.gasPrice.toFixed()),
+      maxFeePerGas: feeData.maxFeePerGas && BigInt(feeData.maxFeePerGas.toFixed()),
+      maxPriorityFeePerGas:
+        feeData.maxPriorityFeePerGas && BigInt(feeData.maxPriorityFeePerGas.toFixed()),
+      nextBaseFee: feeData.nextBaseFee && BigInt(feeData.nextBaseFee.toFixed()),
     },
   };
 }

package/src/logic/index.ts

@@ -6,4 +6,3 @@ export * from "./estimateFees";
 export * from "./listOperations";
 export * from "./craftTransaction";
 export * from "./getSequence";
-export * from "./validateIntent";

package/src/types/transaction.ts

@@ -130,14 +130,6 @@ export type FeeHistory = {
   reward: string[][];
 };
 
-export type ApiFeeData = {
-  maxFeePerGas: bigint | null;
-  maxPriorityFeePerGas: bigint | null;
-  gasPrice: bigint | null;
-  // only used by UI send flow in advanced mode for EIP-1559
-  nextBaseFee: bigint | null;
-};
-
 export type FeeData = {
   maxFeePerGas: BigNumber | null;
   maxPriorityFeePerGas: BigNumber | null;
@@ -156,10 +148,6 @@ export type FeeDataRaw = {
 
 export type Strategy = "slow" | "medium" | "fast";
 
-export type ApiGasOptions = {
-  [key in Strategy]: ApiFeeData;
-};
-
 export type GasOptions = {
   [key in Strategy]: FeeData;
 };

package/lib/__fixtures__/cardano-native-8654e8b350e298c80d2451beb5ed80fc9eee9f38ce6b039fb8706bc34c4f4253544552.json

@@ -1,52 +0,0 @@
-{
-    "type": "TokenCurrency",
-    "id": "cardano/native/8654e8b350e298c80d2451beb5ed80fc9eee9f38ce6b039fb8706bc34c4f4253544552",
-    "contractAddress": "8654e8b350e298c80d2451beb5ed80fc9eee9f38ce6b039fb8706bc34c4f4253544552",
-    "parentCurrency": {
-        "type": "CryptoCurrency",
-        "id": "cardano",
-        "coinType": 1815,
-        "name": "Cardano",
-        "managerAppName": "Cardano ADA",
-        "ticker": "ADA",
-        "scheme": "cardano",
-        "color": "#0A1D2C",
-        "family": "cardano",
-        "blockAvgTime": 20,
-        "units": [
-            {
-                "name": "ada",
-                "code": "ADA",
-                "magnitude": 6
-            },
-            {
-                "name": "Lovelace",
-                "code": "Lovelace",
-                "magnitude": 0
-            }
-        ],
-        "explorerViews": [
-            {
-                "tx": "https://cardanoscan.io/transaction/$hash",
-                "address": "https://cardanoscan.io/address/$address",
-                "stakePool": "https://cardanoscan.io/pool/$poolId"
-            }
-        ],
-        "keywords": [
-            "ada",
-            "cardano"
-        ]
-    },
-    "tokenType": "native",
-    "name": "LOBSTER",
-    "ticker": "$LOBSTER",
-    "delisted": false,
-    "disableCountervalue": false,
-    "units": [
-        {
-            "name": "LOBSTER",
-            "code": "$LOBSTER",
-            "magnitude": 0
-        }
-    ]
-}

package/lib/__fixtures__/ethereum-erc20-usd__coin-0x02b972f304dc24c9bc362e6435c4ad654241f9af916689a4790145c9bcbdf4cf-IN-i0.json

@@ -1,20 +0,0 @@
-{
-    "accountId": "js:2:ethereum:0x6cbcd73cd8e8a42844662f0a0e76d7f79afd933d:+ethereum%2Ferc20%2Fusd~!underscore!~~!underscore!~coin",
-    "blockHash": "0x58ee7556044cd139e569c87c173a6dedbfbeb9ada6693ee6090fd510acee9c21",
-    "blockHeight": 16240731,
-    "contract": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-    "date": "2022-12-22T14:06:23.000Z",
-    "extra": {},
-    "fee": "1595338583295225",
-    "hash": "0x02b972f304dc24c9bc362e6435c4ad654241f9af916689a4790145c9bcbdf4cf",
-    "id": "js:2:ethereum:0x6cbcd73cd8e8a42844662f0a0e76d7f79afd933d:+js%3A2%3Aethereum%3A0x6cbcd73cd8e8a42844662f0a0e76d7f79afd933d%3A%2Bethereum%252Ferc20%252Fusd~!underscore!~~!underscore!~coin~!dash!~0x02b972f304dc24c9bc362e6435c4ad654241f9af916689a4790145c9bcbdf4cf~!dash!~OUT~!dash!~i0-0x02b972f304dc24c9bc362e6435c4ad654241f9af916689a4790145c9bcbdf4cf-IN-i0",
-    "recipients": [
-        "0xC2907EFccE4011C491BbedA8A0fA63BA7aab596C"
-    ],
-    "senders": [
-        "0x6cBCD73CD8e8a42844662f0A0e76D7F79Afd933d"
-    ],
-    "transactionSequenceNumber": 53,
-    "type": "OUT",
-    "value": "2000000"
-}

package/lib/__fixtures__/ethereum-erc20-usd__coin-0x02b972f304dc24c9bc362e6435c4ad654241f9af916689a4790145c9bcbdf4cf-OUT-i0.json

@@ -1,19 +0,0 @@
-{
-    "accountId": "js:2:ethereum:0x6cbcd73cd8e8a42844662f0a0e76d7f79afd933d:+js%3A2%3Aethereum%3A0x6cbcd73cd8e8a42844662f0a0e76d7f79afd933d%3A%2Bethereum%252Ferc20%252Fusd~!underscore!~~!underscore!~coin~!dash!~0x02b972f304dc24c9bc362e6435c4ad654241f9af916689a4790145c9bcbdf4cf~!dash!~OUT~!dash!~i0",
-    "blockHash": "0x58ee7556044cd139e569c87c173a6dedbfbeb9ada6693ee6090fd510acee9c21",
-    "blockHeight": 16240731,
-    "date": "2022-12-22T14:06:23.000Z",
-    "extra": {},
-    "fee": "1595338583295225",
-    "hash": "0x02b972f304dc24c9bc362e6435c4ad654241f9af916689a4790145c9bcbdf4cf",
-    "id": "js:2:ethereum:0x6cbcd73cd8e8a42844662f0a0e76d7f79afd933d:+js%3A2%3Aethereum%3A0x6cbcd73cd8e8a42844662f0a0e76d7f79afd933d%3A%2Bethereum%252Ferc20%252Fusd~!underscore!~~!underscore!~coin~!dash!~0x02b972f304dc24c9bc362e6435c4ad654241f9af916689a4790145c9bcbdf4cf~!dash!~OUT~!dash!~i0-0x02b972f304dc24c9bc362e6435c4ad654241f9af916689a4790145c9bcbdf4cf-OUT-i0",
-    "recipients": [
-        "0xC2907EFccE4011C491BbedA8A0fA63BA7aab596C"
-    ],
-    "senders": [
-        "0x6cBCD73CD8e8a42844662f0A0e76D7F79Afd933d"
-    ],
-    "transactionSequenceNumber": 53,
-    "type": "OUT",
-    "value": "2000000"
-}

package/lib/__tests__/fixtures/cryptoAssetsStore.fixtures.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=cryptoAssetsStore.fixtures.d.ts.map

package/lib/__tests__/fixtures/cryptoAssetsStore.fixtures.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cryptoAssetsStore.fixtures.d.ts","sourceRoot":"","sources":["../../../src/__tests__/fixtures/cryptoAssetsStore.fixtures.ts"],"names":[],"mappings":""}