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

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/exchange/providers/swap.integration.test.ts

@@ -1,19 +1,4 @@
-import { fetchAndMergeProviderData, findExchangeCurrencyData } from "./swap";
-
-describe("findExchangeCurrencyData", () => {
-  it("returns all data in expected format", async () => {
-    // When
-    const currencies = await findExchangeCurrencyData("arbitrum");
-
-    // Then
-    expect(currencies).toEqual({
-      config: "0345544808457468657265756d0d0345544812000000000000a4b1",
-      id: "arbitrum",
-      signature:
-        "30450221008ca557e4acc2fa290a6a44c2b0eb5232712ba69b23df93645a320bcff9789fd9022017e6e05582806a9d4b7b2aaaedbcc3471bd26e10ad686e4f313fc0b1068b5d64",
-    });
-  });
-});
+import { fetchAndMergeProviderData } from "./swap";
 
 describe("fetchAndMergeProviderData", () => {
   it("returns all data in expected format", async () => {
@@ -31,6 +16,11 @@ describe("fetchAndMergeProviderData", () => {
         mainUrl: "https://changelly.com/",
         name: "Changelly",
         needsKYC: false,
+        usefulUrls: [
+          "https://changelly.com/terms-of-use",
+          "https://changelly.com/aml-kyc",
+          "https://support.changelly.com/en/support/tickets/new",
+        ],
         publicKey: {
           curve: "secp256k1",
           data: Buffer.from(
@@ -47,6 +37,33 @@ describe("fetchAndMergeProviderData", () => {
         type: "CEX",
         version: 1,
       },
+      changelly_v2: {
+        displayName: "Changelly",
+        name: "Changelly",
+        useInExchangeApp: true,
+        publicKey: {
+          curve: "secp256k1",
+          data: Buffer.from(
+            "0480d7c0d3a9183597395f58dda05999328da6f18fabd5cda0aff8e8e3fc633436a2dbf48ecb23d40df7c3c7d3e774b77b4b5df0e9f7e08cf1cdf2dba788eb085b",
+            "hex",
+          ),
+        },
+        signature: Buffer.from(
+          "3045022100c2db00da651cfcc84702f75ab5f131a3f037592080ea750a6f665a8cb36797c802200e594938cdf2c836b34717f57487002a0588f2088f64f00a6c4d320fd37db6fa",
+          "hex",
+        ),
+        needsKYC: false,
+        type: "CEX",
+        usefulUrls: [
+          "https://changelly.com/terms-of-use",
+          "https://changelly.com/aml-kyc",
+          "https://support.changelly.com/en/support/tickets/new",
+        ],
+        termsOfUseUrl: "https://changelly.com/terms-of-use",
+        supportUrl: "https://support.changelly.com/en/support/home",
+        mainUrl: "https://changelly.com/",
+        version: 2,
+      },
       changenow: {
         name: "ChangeNOW",
         publicKey: {

package/src/exchange/providers/swap.ts

@@ -15,6 +15,7 @@ export type AdditionalProviderConfig = SwapProviderConfig & { type: "DEX" | "CEX
   version?: number;
   termsOfUseUrl: string;
   supportUrl: string;
+  usefulUrls?: string[];
   mainUrl: string;
   useInExchangeApp: boolean;
   displayName: string;
@@ -39,10 +40,41 @@ const DEFAULT_SWAP_PROVIDERS: Record<string, ProviderConfig & Partial<Additional
     needsKYC: false,
     needsBearerToken: false,
     type: "CEX",
+    usefulUrls: [
+      "https://changelly.com/terms-of-use",
+      "https://changelly.com/aml-kyc",
+      "https://support.changelly.com/en/support/tickets/new",
+    ],
     termsOfUseUrl: "https://changelly.com/terms-of-use",
     supportUrl: "https://support.changelly.com/en/support/home",
     mainUrl: "https://changelly.com/",
   },
+  changelly_v2: {
+    name: "Changelly",
+    publicKey: {
+      curve: "secp256k1",
+      data: Buffer.from(
+        "0480d7c0d3a9183597395f58dda05999328da6f18fabd5cda0aff8e8e3fc633436a2dbf48ecb23d40df7c3c7d3e774b77b4b5df0e9f7e08cf1cdf2dba788eb085b",
+        "hex",
+      ),
+    },
+    signature: Buffer.from(
+      "3045022100c2db00da651cfcc84702f75ab5f131a3f037592080ea750a6f665a8cb36797c802200e594938cdf2c836b34717f57487002a0588f2088f64f00a6c4d320fd37db6fa",
+      "hex",
+    ),
+    needsKYC: false,
+    needsBearerToken: false,
+    type: "CEX",
+    usefulUrls: [
+      "https://changelly.com/terms-of-use",
+      "https://changelly.com/aml-kyc",
+      "https://support.changelly.com/en/support/tickets/new",
+    ],
+    termsOfUseUrl: "https://changelly.com/terms-of-use",
+    supportUrl: "https://support.changelly.com/en/support/home",
+    mainUrl: "https://changelly.com/",
+    version: 2,
+  },
   exodus: {
     name: "exodus",
     publicKey: {

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

@@ -422,6 +422,10 @@ export const DEFAULT_FEATURES: Features = {
     },
   },
 
+  ptxSwapLiveAppKycWarning: {
+    enabled: false,
+  },
+
   llmAnalyticsOptInPrompt: {
     enabled: false,
     params: {
@@ -618,6 +622,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;
+  }
+}