@ledgerhq/live-common 34.36.0 → 34.37.0-next.0

package/src/bridge/generic-alpaca/tests/prepareTransaction.test.ts

@@ -0,0 +1,66 @@
+import { genericPrepareTransaction } from "../prepareTransaction";
+import { getAlpacaApi } from "../alpaca";
+import { transactionToIntent } from "../utils";
+import BigNumber from "bignumber.js";
+import type { TransactionCommon } from "@ledgerhq/types-live";
+
+jest.mock("../alpaca", () => ({
+  getAlpacaApi: jest.fn(),
+}));
+
+jest.mock("../utils", () => ({
+  transactionToIntent: jest.fn(),
+}));
+
+describe("genericPrepareTransaction", () => {
+  const network = "testnet";
+  const kind = "local";
+
+  const account = {
+    id: "test-account",
+    address: "0xabc",
+  } as any;
+
+  const baseTransaction: TransactionCommon & { fees: BigNumber } = {
+    amount: new BigNumber(100_000),
+    fees: new BigNumber(500),
+    recipient: "0xrecipient",
+  };
+
+  const txIntent = { mock: "intent" };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (transactionToIntent as jest.Mock).mockReturnValue(txIntent);
+  });
+
+  it("updates fees if they differ", async () => {
+    const newFee = new BigNumber(700);
+
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: newFee }),
+    });
+
+    const prepareTransaction = genericPrepareTransaction(network, kind);
+    const result = await prepareTransaction(account, { ...baseTransaction });
+
+    expect((result as any).fees.toString()).toBe(newFee.toString());
+    expect(transactionToIntent).toHaveBeenCalledWith(
+      account,
+      expect.objectContaining(baseTransaction),
+    );
+  });
+
+  it("returns original transaction if fees are the same", async () => {
+    const sameFee = baseTransaction.fees;
+
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: sameFee }),
+    });
+
+    const prepareTransaction = genericPrepareTransaction(network, kind);
+    const result = await prepareTransaction(account, { ...baseTransaction });
+
+    expect(result).toStrictEqual(baseTransaction);
+  });
+});

package/src/bridge/generic-alpaca/tests/signOperation.test.ts

@@ -0,0 +1,96 @@
+import { lastValueFrom } from "rxjs";
+import { toArray } from "rxjs/operators";
+import { genericSignOperation } from "../signOperation";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { getAlpacaApi } from "../alpaca";
+import { buildOptimisticOperation, transactionToIntent } from "../utils";
+
+jest.mock("../alpaca", () => ({
+  getAlpacaApi: jest.fn(),
+}));
+
+jest.mock("../utils", () => ({
+  buildOptimisticOperation: jest.fn(),
+  transactionToIntent: jest.fn(),
+}));
+
+describe("genericSignOperation", () => {
+  const network = "xrp";
+  const kind = "local";
+
+  const mockSignerContext = jest.fn();
+  const mockSigner = {
+    getAddress: jest.fn(),
+    signTransaction: jest.fn(),
+  };
+
+  const account = {
+    freshAddressPath: "44'/144'/0'/0/0",
+    address: "rTestAddress",
+  } as any;
+
+  const transaction = {
+    amount: 100_000n,
+    fees: 500n,
+    tag: 1234,
+  } as any;
+
+  const deviceId = "mockDevice";
+
+  const txIntent = {
+    memo: {
+      type: "map",
+      memos: new Map(),
+    },
+  };
+
+  const unsignedTx = "unsignedTx";
+  const signedTx = "signedTx";
+  const pubKey = "pubKey";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      craftTransaction: jest.fn().mockResolvedValue(unsignedTx),
+      combine: jest.fn().mockResolvedValue(signedTx),
+    });
+
+    (transactionToIntent as jest.Mock).mockReturnValue(txIntent);
+    (buildOptimisticOperation as jest.Mock).mockReturnValue({ id: "mock-op" });
+
+    mockSigner.getAddress.mockResolvedValue({ publicKey: pubKey });
+    mockSigner.signTransaction.mockResolvedValue("sig");
+    mockSignerContext.mockImplementation(async (_deviceId, cb) => cb(mockSigner));
+  });
+
+  it("emits full sign operation flow", async () => {
+    const signOperation = genericSignOperation(network, kind)(mockSignerContext);
+    const observable = signOperation({ account, transaction, deviceId });
+
+    const events = await lastValueFrom(observable.pipe(toArray()));
+
+    expect(events[0]).toEqual({ type: "device-signature-requested" });
+    expect(events[1]).toEqual({ type: "device-signature-granted" });
+    expect(events[2]).toEqual({
+      type: "signed",
+      signedOperation: {
+        operation: { id: "mock-op" },
+        signature: signedTx,
+      },
+    });
+
+    expect(transactionToIntent).toHaveBeenCalledWith(account, transaction);
+    expect(txIntent.memo.memos.get("destinationTag")).toBe("1234");
+  });
+
+  it("throws FeeNotLoaded if fees are missing", async () => {
+    const txWithoutFees = { ...transaction };
+    delete txWithoutFees.fees;
+
+    const signOperation = genericSignOperation(network, kind)(mockSignerContext);
+    const observable = signOperation({ account, transaction: txWithoutFees, deviceId });
+
+    await expect(observable.toPromise()).rejects.toThrow(FeeNotLoaded);
+  });
+});

package/src/bridge/generic-alpaca/utils.ts

@@ -0,0 +1,63 @@
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { Account, Operation, OperationType, TransactionCommon } from "@ledgerhq/types-live";
+import {
+  Operation as CoreOperation,
+  Asset,
+  TransactionIntent,
+} from "@ledgerhq/coin-framework/api/types";
+import BigNumber from "bignumber.js";
+import { fromBigNumberToBigInt } from "@ledgerhq/coin-framework/utils";
+
+export function adaptCoreOperationToLiveOperation(
+  accountId: string,
+  op: CoreOperation<Asset>,
+): Operation {
+  return {
+    id: encodeOperationId(accountId, op.tx.hash, op.type),
+    hash: op.tx.hash,
+    accountId,
+    type: op.type as OperationType,
+    value: new BigNumber(op.value.toString()),
+    fee: new BigNumber(op.tx.fees.toString()),
+    blockHash: op.tx.block.hash,
+    blockHeight: op.tx.block.height,
+    senders: op.senders,
+    recipients: op.recipients,
+    date: op.tx.date,
+    transactionSequenceNumber: op.details?.sequence as number,
+    extra: {},
+  };
+}
+
+export function transactionToIntent(
+  _account: Account,
+  transaction: TransactionCommon,
+): TransactionIntent<any> {
+  return {
+    type: "Payment",
+    sender: _account.freshAddress,
+    recipient: transaction.recipient,
+    amount: fromBigNumberToBigInt(transaction.amount, BigInt(0)),
+    asset: null,
+  };
+}
+
+export const buildOptimisticOperation = (
+  account: Account,
+  transaction: TransactionCommon,
+): Operation => {
+  return {
+    id: encodeOperationId(account.id, "", "OUT"),
+    hash: "",
+    type: "OUT",
+    value: transaction.amount,
+    fee: transaction["fees"] ?? BigNumber(0),
+    blockHash: null,
+    blockHeight: null,
+    senders: [account.freshAddress.toString()],
+    recipients: [transaction.recipient],
+    accountId: account.id,
+    date: new Date(),
+    extra: {},
+  };
+};

package/src/bridge/impl.ts

@@ -1,11 +1,29 @@
+import { isAddressSanctioned } from "../sanction";
 import { CurrencyNotSupported } from "@ledgerhq/errors";
-import { decodeAccountId, getMainAccount } from "../account";
 import { getEnv } from "@ledgerhq/live-env";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import {
+  Account,
+  AccountBridge,
+  AccountLike,
+  CurrencyBridge,
+  TransactionStatusCommon,
+} from "@ledgerhq/types-live";
+import { decodeAccountId, getMainAccount } from "../account";
 import { checkAccountSupported } from "../account/index";
 import jsBridges from "../generated/bridge/js";
 import mockBridges from "../generated/bridge/mock";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { Account, AccountBridge, AccountLike, CurrencyBridge } from "@ledgerhq/types-live";
+import { RecipientAddressSanctionedError, UserAddressSanctionedError } from "../sanction/errors";
+import { getAlpacaCurrencyBridge } from "./generic-alpaca/currencyBridge";
+import { getAlpacaAccountBridge } from "./generic-alpaca/accountBridge";
+import { TransactionCommon } from "@ledgerhq/types-live";
+
+const alpacaized = {
+  xrp: true,
+};
+
+let accountBridgeInstance: AccountBridge<any> | null = null;
+let currencyBridgeInstance: CurrencyBridge | null = null;
 
 export const getCurrencyBridge = (currency: CryptoCurrency): CurrencyBridge => {
   if (getEnv("MOCK")) {
@@ -16,6 +34,13 @@ export const getCurrencyBridge = (currency: CryptoCurrency): CurrencyBridge => {
     });
   }
 
+  if (alpacaized[currency.family]) {
+    if (!currencyBridgeInstance) {
+      currencyBridgeInstance = getAlpacaCurrencyBridge(currency.family, "local");
+    }
+    return currencyBridgeInstance;
+  }
+
   const jsBridge = jsBridges[currency.family];
   if (jsBridge) {
     return jsBridge.currencyBridge;
@@ -57,9 +82,66 @@ export function getAccountBridgeByFamily(family: string, accountId?: string): Ac
     }
   }
 
+  if (alpacaized[family]) {
+    if (!accountBridgeInstance) {
+      accountBridgeInstance = getAlpacaAccountBridge(family, "local");
+    }
+    return accountBridgeInstance;
+  }
+
   const jsBridge = jsBridges[family];
   if (!jsBridge) {
-    throw new CurrencyNotSupported("currency bridge not found " + family);
+    throw new CurrencyNotSupported("account currency bridge not found " + family);
   }
-  return jsBridge.accountBridge;
+  return wrapAccountBridge(jsBridge.accountBridge);
+}
+
+function wrapAccountBridge<T extends TransactionCommon>(
+  bridge: AccountBridge<T>,
+): AccountBridge<T> {
+  return {
+    ...bridge,
+    getTransactionStatus: async (...args) => {
+      const blockchainSpecific = await bridge.getTransactionStatus(...args);
+      const common = await commonGetTransactionStatus(...args);
+      const merged = mergeResults(blockchainSpecific, common);
+      return merged;
+    },
+  };
+}
+
+function mergeResults(
+  blockchainSpecific: TransactionStatusCommon,
+  common: Partial<TransactionStatusCommon>,
+): TransactionStatusCommon {
+  const errors = { ...blockchainSpecific.errors, ...common.errors };
+  const warnings = { ...blockchainSpecific.warnings, ...common.warnings };
+  return { ...blockchainSpecific, errors, warnings };
+}
+
+async function commonGetTransactionStatus(
+  account: Account,
+  transaction: TransactionCommon,
+): Promise<Partial<TransactionStatusCommon>> {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+
+  let recipientIsBlacklisted = false;
+  if (transaction.recipient && transaction.recipient !== "") {
+    recipientIsBlacklisted = await isAddressSanctioned(account.currency, transaction.recipient);
+    if (recipientIsBlacklisted) {
+      errors.recipient = new RecipientAddressSanctionedError();
+    }
+  }
+
+  const userIsBlacklisted = await isAddressSanctioned(account.currency, account.freshAddress);
+  if (userIsBlacklisted) {
+    errors.amount = new UserAddressSanctionedError();
+  }
+
+  if (userIsBlacklisted || recipientIsBlacklisted) {
+    // Send log
+  }
+
+  return { errors, warnings };
 }

package/src/config/index.ts

@@ -1,11 +1,20 @@
 import { CryptoCurrency, CryptoCurrencyId } from "@ledgerhq/types-cryptoassets";
 import { ConfigInfo, LiveConfig } from "@ledgerhq/live-config/LiveConfig";
-import { CurrencyConfig } from "@ledgerhq/coin-framework/config";
+import { CurrencyConfig, SharedConfig } from "@ledgerhq/coin-framework/config";
 
 export type CurrencyLiveConfigDefinition = Partial<
   Record<`config_currency_${CryptoCurrencyId}`, ConfigInfo>
 >;
 
+const getSharedConfiguration = (): SharedConfig => {
+  const config = LiveConfig.getValueByKey("config_currency");
+  if (!config) {
+    throw new Error("Configuration config_currency not found, please check Firebase Remote Config");
+  }
+
+  return config;
+};
+
 const getCurrencyConfiguration = <T extends CurrencyConfig>(
   currency: CryptoCurrency,
 ): T & Record<string, unknown> => {
@@ -17,4 +26,4 @@ const getCurrencyConfiguration = <T extends CurrencyConfig>(
   return currencyData;
 };
 
-export { getCurrencyConfiguration };
+export { getCurrencyConfiguration, getSharedConfiguration };

package/src/config/sharedConfig.ts

@@ -36,6 +36,13 @@ const countervaluesConfig: ConfigSchema = {
   },
 };
 
+const sharedCurrencyConfig: ConfigSchema = {
+  config_currency: {
+    type: "object",
+    default: {},
+  },
+};
+
 const liveCommonConfig: ConfigSchema = {
   ...appConfig,
 };
@@ -67,4 +74,5 @@ export const liveConfig: ConfigSchema = {
   ...iconConfig,
   ...tonConfig,
   ...suiConfig,
+  ...sharedCurrencyConfig,
 };

package/src/e2e/enum/OperationType.ts

@@ -0,0 +1,4 @@
+export enum OperationType {
+  Buy = "Buy",
+  Sell = "Sell",
+}

package/src/e2e/enum/{Swap.ts → Provider.ts}

@@ -15,6 +15,7 @@ export class Provider {
   static readonly UNISWAP = new Provider("uniswap", "Uniswap", false, false, false);
   static readonly LIFI = new Provider("lifi", "LI.FI", false, true, false);
   static readonly CIC = new Provider("cic", "CIC", false, true, true);
+  static readonly COINBASE = new Provider("coinbase", "Coinbase", false, true, true);
 
   static getNameByUiName(uiName: string): string {
     const provider = Object.values(Provider).find(p => p.uiName === uiName);

package/src/e2e/models/BuySell.ts

@@ -1,4 +1,5 @@
 import { AccountType } from "../enum/Account";
+import { OperationType } from "../enum/OperationType";
 
 export interface Fiat {
   locale: string;
@@ -9,4 +10,5 @@ export interface BuySell {
   crypto: AccountType;
   fiat: Fiat;
   amount: string;
+  operation: OperationType;
 }

package/src/families/casper/bridge.integration.test.ts

@@ -1,5 +1,5 @@
 import "../../__tests__/test-helpers/setup";
 import { testBridge } from "../../__tests__/test-helpers/bridge";
-import { dataset } from "@ledgerhq/coin-casper/test/index";
+import { dataset } from "@ledgerhq/coin-casper/test";
 
 testBridge(dataset);

package/src/families/casper/config.ts

@@ -1,12 +1,16 @@
-import { ConfigInfo } from "@ledgerhq/live-config/LiveConfig";
+import { CurrencyLiveConfigDefinition } from "../../config";
 
-export const casperConfig: Record<string, ConfigInfo> = {
+export const casperConfig: CurrencyLiveConfigDefinition = {
   config_currency_casper: {
     type: "object",
     default: {
       status: {
         type: "active",
       },
+      infra: {
+        API_CASPER_NODE_ENDPOINT: "https://casper.coin.ledger.com/node/",
+        API_CASPER_INDEXER: "https://casper.coin.ledger.com/indexer/",
+      },
     },
   },
 };

package/src/families/casper/setup.ts

@@ -1,17 +1,20 @@
 // Goal of this file is to inject all necessary device/signer dependency to coin-modules
 
-import { createBridges } from "@ledgerhq/coin-casper/bridge/index";
+import { createBridges } from "@ledgerhq/coin-casper/bridge";
 import Transport from "@ledgerhq/hw-transport";
 import Casper from "@zondax/ledger-casper";
-import casperResolver from "@ledgerhq/coin-casper/signer/index";
+import casperResolver from "@ledgerhq/coin-casper/signer";
 import { signMessage } from "@ledgerhq/coin-casper/hw-signMessage";
 import type { Account, Bridge } from "@ledgerhq/types-live";
 import makeCliTools from "@ledgerhq/coin-casper/test/cli";
 import { CreateSigner, createResolver, executeWithSigner } from "../../bridge/setup";
 import { Resolver } from "../../hw/getAddress/types";
-import { TransactionStatus, Transaction } from "@ledgerhq/coin-casper/types/index";
+import { TransactionStatus, Transaction } from "@ledgerhq/coin-casper/types";
 import { CasperGetAddrResponse, CasperSignature, CasperSigner } from "./types";
+import { getCurrencyConfiguration } from "../../config";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import { getPath, isError } from "./common";
+import { CasperCoinConfig } from "@ledgerhq/coin-casper/config";
 
 const createSigner: CreateSigner<CasperSigner> = (transport: Transport) => {
   const casper = new Casper(transport);
@@ -37,8 +40,12 @@ const createSigner: CreateSigner<CasperSigner> = (transport: Transport) => {
   };
 };
 
+const getCoinConfig: CasperCoinConfig = () =>
+  getCurrencyConfiguration<ReturnType<CasperCoinConfig>>(getCryptoCurrencyById("casper"));
+
 const bridge: Bridge<Transaction, Account, TransactionStatus> = createBridges(
   executeWithSigner(createSigner),
+  getCoinConfig,
 );
 
 const messageSigner = {

package/src/families/casper/types.ts

@@ -1,2 +1,2 @@
 // Encapsulate for LLD & LLM
-export * from "@ledgerhq/coin-casper/types/index";
+export * from "@ledgerhq/coin-casper/types";

package/src/families/xrp/setup.ts

@@ -1,31 +1,18 @@
 // Goal of this file is to inject all necessary device/signer dependency to coin-modules
 
 import Xrp from "@ledgerhq/hw-app-xrp";
-import { Bridge } from "@ledgerhq/types-live";
 import Transport from "@ledgerhq/hw-transport";
-import { createBridges, type XrpCoinConfig } from "@ledgerhq/coin-xrp";
 import xrpResolver from "@ledgerhq/coin-xrp/signer/index";
 import makeCliTools from "@ledgerhq/coin-xrp/test/cli";
-import { Transaction as XrpTransaction } from "@ledgerhq/coin-xrp/types";
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
-import { CreateSigner, createResolver, executeWithSigner } from "../../bridge/setup";
-import { getCurrencyConfiguration } from "../../config";
+import { CreateSigner, createResolver } from "../../bridge/setup";
 import { Resolver } from "../../hw/getAddress/types";
 
 const createSigner: CreateSigner<Xrp> = (transport: Transport) => {
   return new Xrp(transport);
 };
 
-const getCoinConfig = () =>
-  getCurrencyConfiguration<XrpCoinConfig>(getCryptoCurrencyById("ripple"));
-
-const bridge: Bridge<XrpTransaction> = createBridges(
-  executeWithSigner(createSigner),
-  getCoinConfig,
-);
-
 const resolver: Resolver = createResolver(createSigner, xrpResolver);
 
 const cliTools = makeCliTools();
 
-export { bridge, cliTools, resolver };
+export { cliTools, resolver };

package/src/featureFlags/defaultFeatures.ts

@@ -618,6 +618,8 @@ export const DEFAULT_FEATURES: Features = {
   },
   ldmkConnectApp: DEFAULT_FEATURE,
   lldNetworkBasedAddAccount: DEFAULT_FEATURE,
+  llmOfacGeoBlocking: DEFAULT_FEATURE,
+  lldOfacGeoBlocking: DEFAULT_FEATURE,
 };
 
 // Firebase SDK treat JSON values as strings

package/src/generated/bridge/js.ts

@@ -20,7 +20,6 @@ import { bridge as tezos } from "../../families/tezos/setup";
 import { bridge as ton } from "../../families/ton/setup";
 import { bridge as tron } from "../../families/tron/setup";
 import { bridge as vechain } from "../../families/vechain/setup";
-import { bridge as xrp } from "../../families/xrp/setup";
 import { bridge as sui } from "../../families/sui/setup";
 import { bridge as mina } from "../../families/mina/setup";
 
@@ -47,7 +46,6 @@ export default {
   ton,
   tron,
   vechain,
-  xrp,
   sui,
   mina,
 };

package/src/hooks/useOFACGeoBlockCheck.ts

@@ -0,0 +1,37 @@
+import { useEffect, useState } from "react";
+import { useFeature } from "../featureFlags";
+import { useQuery } from "@tanstack/react-query";
+import { getEnv } from "@ledgerhq/live-env";
+
+const baseURL = () => getEnv("LEDGER_COUNTERVALUES_API");
+
+export const useOFACGeoBlockCheck = ({
+  onFinish,
+  geoBlockingFeatureFlagKey,
+}: {
+  onFinish?: () => void;
+  geoBlockingFeatureFlagKey: "llmOfacGeoBlocking" | "lldOfacGeoBlocking";
+}) => {
+  const [blocked, setBlocked] = useState<boolean>(false);
+
+  const platformOfacGeoBlocking = useFeature(geoBlockingFeatureFlagKey);
+
+  const { data, isLoading } = useQuery({
+    queryKey: ["ofac-geo-block", geoBlockingFeatureFlagKey],
+    queryFn: async () => {
+      if (!platformOfacGeoBlocking?.enabled) return false;
+      const res = await fetch(`${baseURL()}/v3/market`);
+      return res.status === 451;
+    },
+  });
+
+  useEffect(() => {
+    if (!platformOfacGeoBlocking?.enabled) return;
+    setBlocked(data ?? false);
+    if (typeof onFinish === "function") {
+      onFinish();
+    }
+  }, [data, onFinish, platformOfacGeoBlocking]);
+
+  return { blocked, isLoading };
+};

package/src/sanction/errors.ts

@@ -0,0 +1,31 @@
+export class UserAddressSanctionedError extends Error {
+  constructor() {
+    super();
+    this.message = this.constructor.name;
+    this.name = this.constructor.name;
+  }
+}
+
+export class UserAddressSanctionedForSendError extends Error {
+  constructor() {
+    super();
+    this.message = this.constructor.name;
+    this.name = this.constructor.name;
+  }
+}
+
+export class UserAddressSanctionedForStakingError extends Error {
+  constructor() {
+    super();
+    this.message = this.constructor.name;
+    this.name = this.constructor.name;
+  }
+}
+
+export class RecipientAddressSanctionedError extends Error {
+  constructor() {
+    super();
+    this.message = this.constructor.name;
+    this.name = this.constructor.name;
+  }
+}

package/src/sanction/index.ts

@@ -0,0 +1,59 @@
+import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
+import axios from "axios";
+import { hours, makeLRUCache } from "@ledgerhq/live-network/cache";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { getCurrencyConfiguration, getSharedConfiguration } from "../config";
+import { CurrencyConfig } from "@ledgerhq/coin-framework/config";
+
+const cache = makeLRUCache(fetchSanctionedAddresses, () => "all_sanctioned_addresses", hours(12));
+
+async function fetchSanctionedAddresses(): Promise<Record<string, string[]>> {
+  const { data } = await axios.get(
+    "https://ofac-compliance.pages.dev/all_sanctioned_addresses.json",
+  );
+  return data;
+}
+
+export async function isAddressSanctioned(
+  currency: CryptoCurrency,
+  address: string,
+): Promise<boolean> {
+  if (!isCheckBlacklistAddressEnabled(currency)) {
+    return false;
+  }
+
+  // Only for testing, should be deleted after
+  const temporarySanctionedAddresses: string[] | undefined =
+    LiveConfig.getValueByKey(`tmp_sanctioned_addresses`);
+
+  const data: Record<string, string[]> = await cache();
+  const addresses = data[currency.ticker] || [];
+
+  if (temporarySanctionedAddresses) {
+    return addresses.concat(temporarySanctionedAddresses).includes(address);
+  }
+
+  return addresses.includes(address);
+}
+
+function isCheckBlacklistAddressEnabled(currency: CryptoCurrency): boolean {
+  const currencyConfig = tryGetCurrencyConfig(currency);
+  if (currencyConfig && "checkBlacklistAddress" in currencyConfig) {
+    return currencyConfig.checkBlacklistAddress === true;
+  } else {
+    const sharedConfiguration = getSharedConfiguration();
+    if ("checkBlacklistAddress" in sharedConfiguration) {
+      return sharedConfiguration.checkBlacklistAddress === true;
+    }
+  }
+
+  return false;
+}
+
+function tryGetCurrencyConfig(currency: CryptoCurrency): CurrencyConfig | undefined {
+  try {
+    return getCurrencyConfiguration(currency);
+  } catch (error) {
+    return undefined;
+  }
+}