internal.ts

import { captureException } from "@sentry/browser";
import {
  Address,
  rpc as SorobanRpc,
  Networks,
  Horizon,
  FeeBumpTransaction,
  StrKey,
  Transaction,
  TransactionBuilder,
  xdr,
  XdrLargeInt,
} from "stellar-sdk";
import BigNumber from "bignumber.js";
import { INDEXER_URL } from "@shared/constants/mercury";
import {
  AutoLockTimeoutMinutes,
  DEFAULT_AUTO_LOCK_TIMEOUT_MINUTES,
} from "@shared/constants/autoLock";
import {
  AssetListResponse,
  AssetsListItem,
  AssetsLists,
} from "@shared/constants/soroban/asset-list";
import {
  getBalance,
  getDecimals,
  getName,
  getSymbol,
  transfer,
} from "@shared/helpers/soroban/token";
import {
  getAssetFromCanonical,
  getCanonicalFromAsset,
  getSdk,
  isCustomNetwork,
  makeDisplayableBalances,
  xlmToStroop,
} from "@shared/helpers/stellar";
import {
  buildSorobanServer,
  getNewTxBuilder,
} from "@shared/helpers/soroban/server";
import {
  getContractSpec as getContractSpecHelper,
  getIsTokenSpec as getIsTokenSpecHelper,
  isContractId,
} from "./helpers/soroban";
import {
  Account,
  AllowList,
  BalanceToMigrate,
  MigratableAccount,
  MigratedAccount,
  Settings,
  IndexerSettings,
  SettingsState,
  ExperimentalFeatures,
  IssuerKey,
  AssetVisibility,
  ApiTokenPrices,
  HorizonOperation,
  UserNotification,
  CollectibleContract,
  DiscoverData,
  RecentProtocolEntry,
  SaveSettingsResponse,
  TrendingAsset,
} from "./types";
import {
  AccountBalancesInterface,
  BalanceMap,
  Balances,
  V2AccountBalances,
} from "./types/backend-api";
import {
  MAINNET_NETWORK_DETAILS,
  DEFAULT_NETWORKS,
  NetworkDetails,
  NETWORKS,
  PASSPHRASE_TO_PRICE_NETWORK,
} from "../constants/stellar";
import { SERVICE_TYPES } from "../constants/services";
import { isDev } from "../helpers/dev";
import { SorobanRpcNotSupportedError } from "../constants/errors";
import { APPLICATION_STATE } from "../constants/applicationState";
import { WalletType } from "../constants/hardwareWallet";
import { sendMessageToBackground } from "./helpers/extensionMessaging";
import { fetchBackendV2 } from "./helpers/fetchBackendV2";
import { getIconUrlFromIssuer } from "./helpers/getIconUrlFromIssuer";
import { getLedgerKeyAccounts } from "./helpers/getLedgerKeyAccounts";
import { redactErrorBody } from "./helpers/redactErrorBody";
import { stellarSdkServer, submitTx } from "./helpers/stellarSdkServer";
import { getIconFromTokenLists } from "./helpers/getIconFromTokenList";
import { mapAccountBalancesV2 } from "./helpers/mapAccountBalancesV2";
import { addBlockaidScanResults } from "./helpers/addBlockaidScanResults";
import { injectLocalTokenBalances } from "./helpers/injectLocalTokenBalances";

const TRANSACTIONS_LIMIT = 100;

export const SendTxStatus: {
  [index: string]: SorobanRpc.Api.SendTransactionStatus;
} = {
  Pending: "PENDING",
  Duplicate: "DUPLICATE",
  Retry: "TRY_AGAIN_LATER",
  Error: "ERROR",
};

export const GetTxStatus: {
  [index: string]: SorobanRpc.Api.GetTransactionStatus;
} = {
  Success: SorobanRpc.Api.GetTransactionStatus.SUCCESS,
  NotFound: SorobanRpc.Api.GetTransactionStatus.NOT_FOUND,
  Failed: SorobanRpc.Api.GetTransactionStatus.FAILED,
};

export const DEFAULT_ALLOW_LIST: AllowList = {
  [NETWORKS.PUBLIC]: {},
  [NETWORKS.TESTNET]: {},
  [NETWORKS.FUTURENET]: {},
};

export const createAccount = async ({
  password,
  isOverwritingAccount = false,
}: {
  password: string;
  isOverwritingAccount: boolean;
}): Promise<{
  publicKey: string;
  allAccounts: Array<Account>;
  hasPrivateKey: boolean;
}> => {
  let publicKey = "";
  let allAccounts = [] as Array<Account>;
  let hasPrivateKey = false;
  let error = "";

  try {
    ({ allAccounts, publicKey, hasPrivateKey, error } =
      await sendMessageToBackground({
        activePublicKey: null,
        password,
        isOverwritingAccount,
        type: SERVICE_TYPES.CREATE_ACCOUNT,
      }));
  } catch (e) {
    console.error(e);
  }

  if (error) {
    throw new Error(error);
  }

  return { allAccounts, publicKey, hasPrivateKey };
};

export const fundAccount = async ({
  activePublicKey,
  publicKey,
}: {
  activePublicKey: string;
  publicKey: string;
}): Promise<void> => {
  try {
    await sendMessageToBackground({
      activePublicKey,
      publicKey,
      type: SERVICE_TYPES.FUND_ACCOUNT,
    });
  } catch (e) {
    console.error(e);
  }
};

export const addAccount = async ({
  activePublicKey,
  password,
}: {
  activePublicKey: string;
  password: string;
}): Promise<{
  publicKey: string;
  allAccounts: Array<Account>;
  hasPrivateKey: boolean;
}> => {
  let error = "";
  let publicKey = "";
  let allAccounts = [] as Array<Account>;
  let hasPrivateKey = false;

  try {
    ({ allAccounts, error, publicKey, hasPrivateKey } =
      await sendMessageToBackground({
        activePublicKey,
        password,
        type: SERVICE_TYPES.ADD_ACCOUNT,
      }));
  } catch (e) {
    console.error(e);
  }

  if (error) {
    throw new Error(error);
  }

  return { allAccounts, publicKey, hasPrivateKey };
};

export const importAccount = async ({
  password,
  privateKey,
  activePublicKey,
}: {
  password: string;
  privateKey: string;
  activePublicKey: string;
}): Promise<{
  publicKey: string;
  allAccounts: Array<Account>;
  hasPrivateKey: boolean;
}> => {
  let error = "";
  let publicKey = "";
  let allAccounts = [] as Array<Account>;
  let hasPrivateKey = false;

  try {
    ({ allAccounts, publicKey, error, hasPrivateKey } =
      await sendMessageToBackground({
        activePublicKey,
        password,
        privateKey,
        type: SERVICE_TYPES.IMPORT_ACCOUNT,
      }));
  } catch (e) {
    console.error(e);
  }

  // @TODO: should this be universal? See asana ticket.
  if (error) {
    throw new Error(error);
  }

  return { allAccounts, publicKey, hasPrivateKey };
};

export const importHardwareWallet = async ({
  activePublicKey,
  publicKey,
  hardwareWalletType,
  bipPath,
}: {
  activePublicKey: string;
  publicKey: string;
  hardwareWalletType: WalletType;
  bipPath: string;
}) => {
  let _publicKey = "";
  let allAccounts = [] as Array<Account>;
  let hasPrivateKey = false;
  let _bipPath = "";
  try {
    ({
      publicKey: _publicKey,
      allAccounts,
      hasPrivateKey,
      bipPath: _bipPath,
    } = await sendMessageToBackground({
      activePublicKey,
      publicKey,
      hardwareWalletType,
      bipPath,
      type: SERVICE_TYPES.IMPORT_HARDWARE_WALLET,
    }));
  } catch (e) {
    console.log({ e });
  }
  return {
    allAccounts,
    publicKey: _publicKey,
    hasPrivateKey,
    bipPath: _bipPath,
  };
};

export const makeAccountActive = ({
  activePublicKey,
  publicKey,
}: {
  activePublicKey: string;
  publicKey: string;
}): Promise<{ publicKey: string; hasPrivateKey: boolean; bipPath: string }> =>
  sendMessageToBackground({
    activePublicKey,
    publicKey,
    type: SERVICE_TYPES.MAKE_ACCOUNT_ACTIVE,
  });

export const updateAccountName = ({
  activePublicKey,
  accountName,
  publicKey,
}: {
  activePublicKey: string;
  accountName: string;
  publicKey: string;
}): Promise<{ allAccounts: Array<Account> }> =>
  sendMessageToBackground({
    activePublicKey,
    accountName,
    publicKey,
    type: SERVICE_TYPES.UPDATE_ACCOUNT_NAME,
  });

export const loadAccount = (): Promise<{
  hasPrivateKey: boolean;
  publicKey: string;
  applicationState: APPLICATION_STATE;
  allAccounts: Array<Account>;
  bipPath: string;
  tokenIdList: string[];
}> =>
  sendMessageToBackground({
    activePublicKey: null,
    type: SERVICE_TYPES.LOAD_ACCOUNT,
  });

export const getMnemonicPhrase = async (): Promise<{
  mnemonicPhrase: string;
}> => {
  let response = { mnemonicPhrase: "" };

  try {
    response = await sendMessageToBackground({
      activePublicKey: null,
      type: SERVICE_TYPES.GET_MNEMONIC_PHRASE,
    });
  } catch (e) {
    console.error(e);
  }
  return response;
};

export const getMigratedMnemonicPhrase = async (): Promise<{
  mnemonicPhrase: string;
}> => {
  let response = { mnemonicPhrase: "" };

  try {
    response = await sendMessageToBackground({
      activePublicKey: null,
      type: SERVICE_TYPES.GET_MIGRATED_MNEMONIC_PHRASE,
    });
  } catch (e) {
    console.error(e);
  }
  return response;
};

export const confirmMnemonicPhrase = async (
  mnemonicPhraseToConfirm: string,
): Promise<{
  isCorrectPhrase: boolean;
  applicationState: APPLICATION_STATE;
}> => {
  let response = {
    isCorrectPhrase: false,
    applicationState: APPLICATION_STATE.PASSWORD_CREATED,
  };

  try {
    response = await sendMessageToBackground({
      activePublicKey: null,
      mnemonicPhraseToConfirm,
      type: SERVICE_TYPES.CONFIRM_MNEMONIC_PHRASE,
    });
  } catch (e) {
    console.error(e);
  }
  return response;
};

export const confirmMigratedMnemonicPhrase = async (
  mnemonicPhraseToConfirm: string,
): Promise<{
  isCorrectPhrase: boolean;
}> => {
  let response = {
    isCorrectPhrase: false,
  };

  try {
    response = await sendMessageToBackground({
      activePublicKey: null,
      mnemonicPhraseToConfirm,
      type: SERVICE_TYPES.CONFIRM_MIGRATED_MNEMONIC_PHRASE,
    });
  } catch (e) {
    console.error(e);
  }
  return response;
};

export const recoverAccount = async ({
  password,
  recoverMnemonic,
  isOverwritingAccount = false,
}: {
  password: string;
  recoverMnemonic: string;
  isOverwritingAccount: boolean;
}): Promise<{
  publicKey: string;
  allAccounts: Array<Account>;
  hasPrivateKey: boolean;
  error: string;
}> => {
  let publicKey = "";
  let allAccounts = [] as Array<Account>;
  let hasPrivateKey = false;
  let error = "";

  try {
    ({ allAccounts, publicKey, hasPrivateKey, error } =
      await sendMessageToBackground({
        activePublicKey: null,
        password,
        recoverMnemonic,
        isOverwritingAccount,
        type: SERVICE_TYPES.RECOVER_ACCOUNT,
      }));
  } catch (e) {
    console.error(e);
  }

  return { allAccounts, publicKey, hasPrivateKey, error };
};

export const confirmPassword = async (
  password: string,
): Promise<{
  publicKey: string;
  hasPrivateKey: boolean;
  applicationState: APPLICATION_STATE;
  allAccounts: Array<Account>;
  bipPath: string;
}> => {
  let response = {
    publicKey: "",
    hasPrivateKey: false,
    applicationState: APPLICATION_STATE.MNEMONIC_PHRASE_CONFIRMED,
    allAccounts: [] as Array<Account>,
    bipPath: "",
  };
  try {
    response = await sendMessageToBackground({
      activePublicKey: null,
      password,
      type: SERVICE_TYPES.CONFIRM_PASSWORD,
    });
  } catch (e) {
    console.error(e);
  }

  return response;
};

export const getAccountInfo = async ({
  publicKey,
  networkDetails,
}: {
  publicKey: string;
  networkDetails: NetworkDetails;
}) => {
  const { networkUrl } = networkDetails;

  const server = new Horizon.Server(networkUrl);

  let account;
  let signerArr = { records: [] as Horizon.ServerApi.AccountRecord[] };

  try {
    account = await server.loadAccount(publicKey);
    signerArr = await server.accounts().forSigner(publicKey).call();
  } catch (e) {
    console.error(e);
  }

  return {
    account,
    isSigner: signerArr.records.length > 1,
  };
};

export const getMigratableAccounts = async () => {
  let migratableAccounts: MigratableAccount[] = [];

  try {
    ({ migratableAccounts } = await sendMessageToBackground({
      activePublicKey: null,
      type: SERVICE_TYPES.GET_MIGRATABLE_ACCOUNTS,
    }));
  } catch (e) {
    console.error(e);
  }

  return { migratableAccounts };
};

/**
 * Fetches the seed-derived analytics user id from the background. Returns
 * `null` when locked (no active session) or if the message fails.
 */
export const getAnalyticsUserId = async (): Promise<{
  analyticsUserId: string | null;
}> => {
  let analyticsUserId: string | null = null;

  try {
    ({ analyticsUserId } = await sendMessageToBackground({
      activePublicKey: null,
      type: SERVICE_TYPES.GET_ANALYTICS_USER_ID,
    }));
  } catch (e) {
    console.error(e);
  }

  return { analyticsUserId };
};

export const migrateAccounts = async ({
  balancesToMigrate,
  isMergeSelected,
  recommendedFee,
}: {
  balancesToMigrate: BalanceToMigrate[];
  isMergeSelected: boolean;
  recommendedFee: string;
}): Promise<{
  publicKey: string;
  migratedAccounts: Array<MigratedAccount>;
  allAccounts: Array<Account>;
  hasPrivateKey: boolean;
  error: string;
}> => {
  let publicKey = "";
  let migratedAccounts = [] as Array<MigratedAccount>;
  let allAccounts = [] as Array<Account>;
  let hasPrivateKey = false;
  let error = "";

  try {
    ({ migratedAccounts, allAccounts, publicKey, hasPrivateKey, error } =
      await sendMessageToBackground({
        activePublicKey: null,
        balancesToMigrate,
        isMergeSelected,
        recommendedFee,
        type: SERVICE_TYPES.MIGRATE_ACCOUNTS,
      }));
  } catch (e) {
    console.error(e);
  }

  return { migratedAccounts, allAccounts, publicKey, hasPrivateKey, error };
};

export const getAccountIndexerBalances = async ({
  publicKey,
  networkDetails,
  shouldSkipScan,
}: {
  publicKey: string;
  networkDetails: NetworkDetails;
  shouldSkipScan?: boolean;
}): Promise<AccountBalancesInterface> => {
  const contractIds = await getTokenIds({
    activePublicKey: publicKey,
    network: networkDetails.network as NETWORKS,
  });
  const url = new URL(`${INDEXER_URL}/account-balances/${publicKey}`);
  url.searchParams.append("network", networkDetails.network);
  if (shouldSkipScan) {
    url.searchParams.append("should_skip_scan", "true");
  }
  for (const id of contractIds) {
    url.searchParams.append("contract_ids", id);
  }
  const response = await fetch(url.href);
  const data = (await response.json()) as AccountBalancesInterface;
  if (!response.ok) {
    const _err = JSON.stringify(data);
    captureException(
      `Failed to fetch account balances - ${response.status}: ${response.statusText}`,
    );
    throw new Error(_err);
  }

  if ("error" in data && (data?.error?.horizon || data?.error?.soroban)) {
    captureException(
      `Failed to fetch account balances - ${response.status}: ${response.statusText}`,
    );
  }

  const formattedBalances = {} as NonNullable<
    AccountBalancesInterface["balances"]
  >;
  for (const balanceKey of Object.keys(data.balances || {})) {
    const balance = data.balances![balanceKey];
    formattedBalances[balanceKey] = {
      ...balance,
      available: new BigNumber(balance.available),
      total: new BigNumber(balance.total),
    };
  }
  return {
    ...data,
    balances: formattedBalances,
    // v1 returns a contract-token balance only for an ID it was handed, so
    // every locally saved contract is removable from the balances view.
    localOnlyTokenIds: contractIds,
  };
};

export const getAccountBalancesV2 = async ({
  publicKey,
  networkDetails,
  shouldSkipScan,
}: {
  publicKey: string;
  networkDetails: NetworkDetails;
  shouldSkipScan?: boolean;
}): Promise<AccountBalancesInterface> => {
  // Multi-address fan-out endpoint; the extension fetches one account at a
  // time. Addresses travel in the POST body, so the URL carries no G-address
  // (unlike the v1 GET path, which needs the beforeSend URL scrubber). The
  // *response* does key its results by address, so bodies reported to Sentry
  // below go through redactErrorBody — beforeSend only rewrites request URLs,
  // never message strings.
  //
  // This is a freighter-backend-v2 call, so it goes through the background
  // chokepoint (callBackendV2), which attaches the per-request JWT (#2879).
  // Balances are only fetched from an unlocked wallet, so the request always
  // carries the JWT. The query lives in the path so callBackendV2 signs the
  // JWT's methodAndPath over the server's full request-target (path + query).
  const { status, body } = await fetchBackendV2({
    method: "POST",
    path: `/accounts/balances?network=${networkDetails.network}`,
    body: JSON.stringify({ addresses: [publicKey] }),
  });

  // Mirror getTokenPrices: a 200 without a `data` payload is still a failure —
  // callers' try/catch only handles throws, not bad returns.
  const parsedResponse = body as { data?: V2AccountBalances[] };
  if (status !== 200 || !parsedResponse?.data) {
    const _err = JSON.stringify(body);
    captureException(
      `Failed to fetch account balances v2 - ${status}: ${redactErrorBody(
        body,
      )}`,
    );
    throw new Error(_err);
  }

  const account = parsedResponse.data.find(
    (accountBalances) => accountBalances.address === publicKey,
  );
  // The backend includes every requested address in the fan-out result, with
  // is_funded=false for unfunded accounts. A missing entry is a malformed
  // response — treating it as "unfunded" would render (and cache) a funded
  // wallet as empty.
  if (!account) {
    captureException(
      `v2 balances response is missing the requested account - ${status}: ${redactErrorBody(
        body,
      )}`,
    );
    throw new Error(
      `v2 balances response is missing the requested account ${publicKey}`,
    );
  }
  // v2 takes account addresses only, so the locally saved custom-token
  // contract IDs the v1 path sent as `contract_ids` hints are merged in here
  // instead. Skipped for an unfunded account: the not-funded UI renders in
  // place of balances, so resolving tokens would only burn requests.
  const mappedBalances = mapAccountBalancesV2(account);
  const mergedBalances = account.is_funded
    ? await injectLocalTokenBalances({
        accountBalances: mappedBalances,
        backendTokenIds: new Set(
          (account.balances || []).map((balance) => balance.token_id),
        ),
        localTokenIds: await getTokenIds({
          activePublicKey: publicKey,
          network: networkDetails.network as NETWORKS,
        }),
        networkPassphrase: networkDetails.networkPassphrase,
        fetchTokenDetails: (contractId) =>
          getTokenDetails({
            contractId,
            publicKey,
            networkDetails,
            shouldFetchBalance: true,
          }),
      })
    : mappedBalances;

  // The v2 response has no Blockaid data yet — replicate the v1 backend's
  // scan-and-merge client-side so both paths return the same payload. Runs
  // after the merge so locally added tokens are scanned too, as they were on
  // v1.
  return await addBlockaidScanResults(
    mergedBalances,
    networkDetails,
    shouldSkipScan,
  );
};

export const getTokenPrices = async (
  tokens: string[],
  networkDetails: NetworkDetails,
  // Required, not defaulted: callers must thread the `use_token_prices_v2`
  // feature flag so Amplitude can roll back to the v1 endpoint without a
  // release. A default silently opts new callers into v2 and defeats the
  // kill switch.
  useV2: boolean,
  // Cancels the request when the caller no longer needs the answer (e.g. the
  // confirmation price snapshot's terminal-status deadline). A true network
  // abort on the v1 path; the v2 request runs in the background service
  // worker across a message boundary the signal cannot cross, so there it
  // only skips a not-yet-sent request and rejects a no-longer-wanted result.
  signal?: AbortSignal,
): Promise<ApiTokenPrices> => {
  // NOTE: API does not accept LP IDs or custom tokens
  const filteredTokens = tokens.filter((tokenId) => {
    const asset = getAssetFromCanonical(tokenId);
    return !tokenId.includes(":lp") && !isContractId(asset.issuer);
  });

  const requestBody = JSON.stringify({ tokens: filteredTokens });

  // The v2 token-prices endpoint is a freighter-backend-v2 call, so it goes
  // through the background chokepoint (callBackendV2), which attaches the
  // per-request JWT (#2879). token-prices is only ever fetched from an unlocked
  // wallet (a locked wallet shows the login screen), so this request always
  // carries the JWT. The v1 path below is the legacy indexer, a direct fetch.
  if (useV2) {
    // The v2 token-prices endpoint only supports pubnet and testnet. Derive the
    // price network from the passphrase rather than networkDetails.network so
    // that custom networks sharing the pubnet/testnet passphrase (stored as
    // STANDALONE) still resolve to the correct supported network. Anything else
    // (Futurenet, custom passphrases) is skipped to avoid a guaranteed error and
    // Sentry noise.
    const priceNetwork =
      PASSPHRASE_TO_PRICE_NETWORK[networkDetails.networkPassphrase];
    if (!priceNetwork) {
      return {};
    }
    // Nothing priceable left after filtering, so skip the request rather than
    // POST an empty tokens array and risk a 4xx that surfaces as an error.
    if (!filteredTokens.length) {
      return {};
    }

    if (signal?.aborted) {
      throw new DOMException("token-prices request aborted", "AbortError");
    }

    // Query lives in the path so callBackendV2 signs the JWT's methodAndPath
    // over the server's full request-target (path + query) — see #2879.
    const { status, body } = await fetchBackendV2({
      method: "POST",
      path: `/token-prices?network=${priceNetwork}`,
      body: requestBody,
    });

    // The background request cannot be cancelled mid-flight (see `signal`
    // param doc); reject a result nobody wants instead of returning it.
    if (signal?.aborted) {
      throw new DOMException("token-prices request aborted", "AbortError");
    }

    // Mirror getDiscoverData: a 200 without a `data` payload is still a
    // failure — returning undefined would violate the Promise<ApiTokenPrices>
    // contract (the caller's try/catch only handles throws, not bad returns).
    const parsed = body as { data?: ApiTokenPrices };
    if (status !== 200 || !parsed?.data) {
      const _err = JSON.stringify(body);
      captureException(
        `Failed to fetch token prices - ${status}: ${redactErrorBody(body)}`,
      );
      throw new Error(_err);
    }

    return parsed.data;
  }

  // v1 (legacy) path — direct fetch to the v1 indexer, not a backend-v2 call.
  const url = new URL(`${INDEXER_URL}/token-prices`);
  const options = {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: requestBody,
    signal,
  };
  const response = await fetch(url.href, options);
  const parsedResponse = (await response.json()) as { data: ApiTokenPrices };

  if (!response.ok) {
    const _err = JSON.stringify(parsedResponse);
    captureException(
      `Failed to fetch token prices - ${response.status}: ${response.statusText}`,
    );
    throw new Error(_err);
  }

  return parsedResponse.data;
};

export const getDiscoverData = async (): Promise<DiscoverData> => {
  const { status, body } = await fetchBackendV2({
    method: "GET",
    path: "/protocols",
  });

  const parsed = body as {
    data?: {
      protocols: {
        description: string;
        icon_url: string;
        name: string;
        website_url: string;
        tags: string[];
        is_blacklisted: boolean;
        background_url?: string;
        is_trending: boolean;
      }[];
    };
  };

  if (status !== 200 || !parsed?.data) {
    const _err = JSON.stringify(parsed);
    captureException(`Failed to fetch discover entries - ${status}`);
    throw new Error(_err);
  }

  return parsed.data.protocols.map((entry) => ({
    description: entry.description,
    iconUrl: entry.icon_url,
    name: entry.name,
    websiteUrl: entry.website_url,
    tags: entry.tags,
    isBlacklisted: entry.is_blacklisted,
    backgroundUrl: entry.background_url,
    isTrending: entry.is_trending,
  }));
};

export const getSorobanTokenBalance = async (
  server: SorobanRpc.Server,
  contractId: string,
  txBuilders: {
    // need a builder per operation, Soroban currently has single op transactions
    balance: TransactionBuilder;
    name: TransactionBuilder;
    decimals: TransactionBuilder;
    symbol: TransactionBuilder;
  },
  balanceParams: xdr.ScVal[],
) => {
  // Right now we can only have 1 operation per TX in Soroban
  // for now we need to do 4 tx simulations to show 1 user balance. :(
  // TODO: figure out how to fetch ledger keys to do this more efficiently
  const decimals = await getDecimals(contractId, server, txBuilders.decimals);
  const name = await getName(contractId, server, txBuilders.name);
  const symbol = await getSymbol(contractId, server, txBuilders.symbol);
  const balance = await getBalance(
    contractId,
    balanceParams,
    server,
    txBuilders.balance,
  );

  return {
    balance,
    decimals,
    name,
    symbol,
  };
};

export const getAccountBalancesStandalone = async ({
  publicKey,
  networkDetails,
  isMainnet,
}: {
  publicKey: string;
  networkDetails: NetworkDetails;
  isMainnet: boolean;
}) => {
  const { network, networkUrl, networkPassphrase } = networkDetails;

  let balances = {} as BalanceMap;
  let isFunded = null;
  let subentryCount = 0;

  try {
    const server = stellarSdkServer(networkUrl, networkPassphrase);
    const accountSummary = await server.accounts().accountId(publicKey).call();

    const displayableBalances = await makeDisplayableBalances(
      accountSummary,
      isMainnet,
    );
    const sponsor = accountSummary.sponsor
      ? { sponsor: accountSummary.sponsor }
      : {};
    const resp = {
      ...sponsor,
      id: accountSummary.id,
      subentryCount: accountSummary.subentry_count,
      sponsoredCount: accountSummary.num_sponsored,
      sponsoringCount: accountSummary.num_sponsoring,
      inflationDestination: accountSummary.inflation_destination,
      thresholds: accountSummary.thresholds,
      signers: accountSummary.signers,
      flags: accountSummary.flags,
      sequenceNumber: accountSummary.sequence,
      balances: displayableBalances,
    };

    balances = resp.balances;
    subentryCount = resp.subentryCount;

    for (let i = 0; i < Object.keys(resp.balances).length; i++) {
      const k = Object.keys(resp.balances)[i];
      const v = resp.balances[k];
      if (v.liquidityPoolId) {
        const server = stellarSdkServer(networkUrl, networkPassphrase);

        const lp = await server
          .liquidityPools()
          .liquidityPoolId(v.liquidityPoolId)
          .call();
        balances[k] = {
          ...balances[k],
          liquidityPoolId: v.liquidityPoolId,
          reserves: lp.reserves,
        };
      }
    }
    isFunded = true;
  } catch (e) {
    console.error(e);
    return {
      balances,
      isFunded: false,
      subentryCount,
    } as AccountBalancesInterface;
  }

  // Get token balances to combine with classic balances
  const tokenIdList = await getTokenIds({
    activePublicKey: publicKey,
    network: network as NETWORKS,
  });

  const tokenBalances = {} as any;

  if (tokenIdList.length) {
    if (!networkDetails.sorobanRpcUrl) {
      throw new SorobanRpcNotSupportedError();
    }

    const server = buildSorobanServer(
      networkDetails.sorobanRpcUrl,
      networkDetails.networkPassphrase,
    );

    const params = [new Address(publicKey).toScVal()];

    for (let i = 0; i < tokenIdList.length; i += 1) {
      const tokenId = tokenIdList[i];
      /*
        Right now, Soroban transactions only support 1 operation per tx
        so we need a builder per value from the contract,
        once/if multi-op transactions are supported this can send
        1 tx with an operation for each value.
      */
      try {
        const { balance, symbol, ...rest } = await getSorobanTokenBalance(
          server,
          tokenId,
          {
            balance: await getNewTxBuilder(publicKey, networkDetails, server),
            name: await getNewTxBuilder(publicKey, networkDetails, server),
            decimals: await getNewTxBuilder(publicKey, networkDetails, server),
            symbol: await getNewTxBuilder(publicKey, networkDetails, server),
          },
          params,
        );

        const total = new BigNumber(balance);

        tokenBalances[`${symbol}:${tokenId}`] = {
          token: { issuer: { key: tokenId }, code: symbol },
          contractId: tokenId,
          total,
          symbol,
          ...rest,
        };
      } catch (e) {
        console.error(`Token "${tokenId}" missing data on RPC server`);
      }
    }
  }

  return {
    balances: { ...balances, ...tokenBalances },
    isFunded,
    subentryCount,
    // Contract tokens on this path exist only because they are in the local
    // list, so all of them are removable from the balances view.
    localOnlyTokenIds: tokenIdList,
  } as AccountBalancesInterface;
};

export const getAccountHistoryStandalone = async ({
  publicKey,
  networkDetails,
}: {
  publicKey: string;
  networkDetails: NetworkDetails;
}): Promise<HorizonOperation[]> => {
  const { networkUrl, networkPassphrase } = networkDetails;

  let operations = [] as HorizonOperation[];

  try {
    const server = stellarSdkServer(networkUrl, networkPassphrase);

    const operationsData = await server
      .operations()
      .forAccount(publicKey)
      .order("desc")
      .join("transactions")
      .limit(TRANSACTIONS_LIMIT)
      .includeFailed(true)
      .call();

    operations = (operationsData.records as HorizonOperation[]) || [];
  } catch (e) {
    console.error(e);
  }

  return operations;
};

export const getIndexerAccountHistory = async ({
  publicKey,
  networkDetails,
}: {
  publicKey: string;
  networkDetails: NetworkDetails;
}): Promise<HorizonOperation[]> => {
  try {
    const url = new URL(
      `${INDEXER_URL}/account-history/${publicKey}?network=${networkDetails.network}&is_failed_included=true`,
    );

    const response = await fetch(url.href);

    const data = await response.json();
    if (!response.ok) {
      throw new Error(data);
    }

    return data;
  } catch (e) {
    console.error(e);
    return [];
  }
};

export const getContractSpec = async ({
  contractId,
  networkDetails,
}: {
  contractId: string;
  networkDetails: NetworkDetails;
}): Promise<Record<string, any>> => {
  if (isCustomNetwork(networkDetails)) {
    const data = await getContractSpecHelper(
      contractId,
      networkDetails.networkUrl,
    );
    return data;
  }
  const url = new URL(
    `${INDEXER_URL}/contract-spec/${contractId}?network=${networkDetails.network}`,
  );
  const response = await fetch(url.href);
  const { data, error } = await response.json();
  if (!response.ok) {
    throw new Error(error);
  }

  return data;
};

export const getIsTokenSpec = async ({
  contractId,
  networkDetails,
}: {
  contractId: string;
  networkDetails: NetworkDetails;
}): Promise<boolean> => {
  if (isCustomNetwork(networkDetails)) {
    const data = await getIsTokenSpecHelper(
      contractId,
      networkDetails.networkUrl,
    );
    return data;
  }
  const url = new URL(
    `${INDEXER_URL}/token-spec/${contractId}?network=${networkDetails.network}`,
  );
  const response = await fetch(url.href);
  const { data, error } = await response.json();
  if (!response.ok) {
    throw new Error(error);
  }

  return data;
};

export const getAccountHistory = async (
  publicKey: string,
  networkDetails: NetworkDetails,
) => {
  if (isCustomNetwork(networkDetails)) {
    return await getAccountHistoryStandalone({
      publicKey,
      networkDetails,
    });
  }
  return await getIndexerAccountHistory({
    publicKey,
    networkDetails,
  });
};

export const getAccountBalances = async (
  publicKey: string,
  networkDetails: NetworkDetails,
  isMainnet: boolean,
  shouldSkipScan: boolean | undefined,
  // Required, not defaulted: callers must thread the `use_balances_v2` feature
  // flag so Amplitude can roll back to the v1 endpoint without a release. A
  // default silently opts new callers into v2 and defeats the kill switch.
  useV2: boolean,
) => {
  if (isCustomNetwork(networkDetails)) {
    return await getAccountBalancesStandalone({
      publicKey,
      networkDetails,
      isMainnet,
    });
  }
  // The v2 balances endpoint only supports pubnet and testnet; Futurenet
  // stays on v1 regardless of the flag.
  const isV2SupportedNetwork =
    networkDetails.network === NETWORKS.PUBLIC ||
    networkDetails.network === NETWORKS.TESTNET;
  if (useV2 && isV2SupportedNetwork) {
    return await getAccountBalancesV2({
      publicKey,
      networkDetails,
      shouldSkipScan,
    });
  }
  return await getAccountIndexerBalances({
    publicKey,
    networkDetails,
    shouldSkipScan,
  });
};

export const getTokenDetails = async ({
  contractId,
  publicKey,
  networkDetails,
  shouldFetchBalance,
  signal,
}: {
  contractId: string;
  publicKey: string;
  networkDetails: NetworkDetails;
  shouldFetchBalance?: boolean;
  signal?: AbortSignal;
}): Promise<{
  name: string;
  decimals: number;
  symbol: string;
  balance?: string;
} | null> => {
  try {
    if (isCustomNetwork(networkDetails)) {
      if (!networkDetails.sorobanRpcUrl) {
        throw new SorobanRpcNotSupportedError();
      }

      // You need one Tx Builder per call in Soroban right now
      const server = buildSorobanServer(
        networkDetails.sorobanRpcUrl,
        networkDetails.networkPassphrase,
      );
      const name = await getName(
        contractId,
        server,
        await getNewTxBuilder(publicKey, networkDetails, server),
      );
      const symbol = await getSymbol(
        contractId,
        server,
        await getNewTxBuilder(publicKey, networkDetails, server),
      );
      const decimals = await getDecimals(
        contractId,
        server,
        await getNewTxBuilder(publicKey, networkDetails, server),
      );

      let balance;
      if (shouldFetchBalance) {
        balance = await getBalance(
          contractId,
          [new Address(publicKey).toScVal()],
          server,
          await getNewTxBuilder(publicKey, networkDetails, server),
        );
      }

      return {
        name,
        symbol,
        decimals,
        ...(balance ? { balance: balance.toString() } : {}),
      };
    }

    const response = await fetch(
      `${INDEXER_URL}/token-details/${contractId}?pub_key=${publicKey}&network=${
        networkDetails.network
      }${shouldFetchBalance ? "&should_fetch_balance=true" : ""}`,
      { signal },
    );
    const data = await response.json();
    if (!response.ok) {
      throw new Error(data);
    }

    return data;
  } catch (error) {
    if (signal?.aborted) {
      return null;
    }
    console.error(error);
    captureException(
      `Failed to fetch token details - ${JSON.stringify(
        error,
      )} - ${contractId} - ${networkDetails.network}`,
    );
    return null;
  }
};

export const getAssetIconCache = async ({
  activePublicKey,
}: {
  activePublicKey: string | null;
}) => {
  let icons = {};
  try {
    ({ icons } = await sendMessageToBackground({
      activePublicKey,
      type: SERVICE_TYPES.GET_CACHED_ASSET_ICON_LIST,
    }));
  } catch (e) {
    return { icons };
  }
  return { icons };
};

/*
  getAssetIcons is used to get the icons for the assets in the balances.
  It can be used with or without lookup. Lookup is keyed off of passing assetListsData and networkDetails.
  
  Using this method without lookup is fastest as it just consults the cache and then returns the icons. 
  This is useful for quickly getting the icons without extra network calls.

  Using this method with lookup is slower as it needs to fetch the token lists and the issuer.
  This is useful for getting the icons for the first time. Once we've retrieved an icon, 
  we'll store it in the background's storage and then use this cache for future lookups.
*/

export const getAssetIcons = async ({
  balances,
  networkDetails,
  assetsListsData,
  cachedIcons,
  additionalAssetIds,
}: {
  balances: Balances;
  networkDetails?: NetworkDetails;
  assetsListsData?: AssetListResponse[];
  cachedIcons: Record<string, string | null>;
  // Canonicals to resolve alongside the held balances, even when the account
  // doesn't hold them (e.g. the swap flow's default destination). Mirrors
  // getTokenPrices' additionalAssetIds.
  additionalAssetIds?: string[];
}) => {
  const assetIcons = {} as { [code: string]: string | null };
  const skipLookup = !assetsListsData || !networkDetails;
  const domainsToFetch = [] as { key: string; code: string }[];

  if (balances) {
    const balanceValues = Object.values(balances);

    for (let i = 0; i < balanceValues.length; i++) {
      let icon = "";
      const { token, contractId } = balanceValues[i];
      if (token && "issuer" in token) {
        const {
          issuer: { key },
          code,
        } = token;

        let canonical = getCanonicalFromAsset(code, key);
        const cachedIcon = cachedIcons[canonical];
        if (cachedIcon) {
          assetIcons[canonical] = cachedIcon;
          continue;
        }

        if (cachedIcon === null) {
          // if we've tried to fetch this icon before and it wasn't found, we marked it as null
          // don't bother trying to fetch it again
          // this null value is only stored in Redux, so we will re-try on next app reload
          continue;
        }

        if (skipLookup) {
          continue;
        }

        if (!icon) {
          // if we don't have the icon, we try to get it from the token lists
          const tokenListIcon = await getIconFromTokenLists({
            issuerId: key,
            contractId,
            code,
            assetsListsData,
          });
          if (tokenListIcon.icon && tokenListIcon.canonicalAsset) {
            icon = tokenListIcon.icon;
            canonical = tokenListIcon.canonicalAsset;
          } else {
            // if we still don't have the icon, we try to get it from the issuer,
            // aggregate the missing icons and we'll fetch all the domains at once
            domainsToFetch.push({ key, code });
          }
        }

        // we assign null here if we checked all sources and still don't have the icon
        assetIcons[canonical] = icon || null;
      }
    }
  }

  // Unheld extras run the same cache -> token lists -> issuer-toml chain as
  // the held balances above (toml via the shared domainsToFetch batch below).
  for (const canonical of additionalAssetIds || []) {
    const [code, key] = canonical.split(":");
    if (!key || canonical in assetIcons) {
      // native (no issuer segment) or already covered by a held balance
      continue;
    }

    const cachedIcon = cachedIcons[canonical];
    if (cachedIcon) {
      assetIcons[canonical] = cachedIcon;
      continue;
    }
    if (cachedIcon === null || skipLookup) {
      continue;
    }

    const tokenListIcon = await getIconFromTokenLists({
      issuerId: isContractId(key) ? undefined : key,
      contractId: isContractId(key) ? key : undefined,
      code,
      assetsListsData,
    });
    if (tokenListIcon.icon) {
      assetIcons[canonical] = tokenListIcon.icon;
    } else if (!isContractId(key)) {
      domainsToFetch.push({ key, code });
    } else {
      assetIcons[canonical] = null;
    }
  }

  if (domainsToFetch.length > 0 && networkDetails) {
    const assetDomains = await getAssetDomains({
      assetIssuerDomainsToFetch: domainsToFetch.map(({ key }) => key),
      networkDetails,
    });

    const iconsToFetch = [] as Promise<void>[];
    for (const { key, code } of domainsToFetch) {
      const canonical = getCanonicalFromAsset(code, key);
      if (assetDomains[key]) {
        const fetchIcon = getIconUrlFromIssuer({
          key,
          code,
          networkDetails,
          homeDomain: assetDomains[key],
        }).then((icon) => {
          assetIcons[canonical] = icon || null;
        });

        iconsToFetch.push(fetchIcon);
      } else {
        assetIcons[canonical] = null;
      }
    }
    await Promise.all(iconsToFetch);
  }
  return assetIcons;
};

export const retryAssetIcon = async ({
  key,
  code,
  assetIcons,
  networkDetails,
  activePublicKey,
}: {
  key: string;
  code: string;
  assetIcons: { [code: string]: string | null };
  networkDetails: NetworkDetails;
  activePublicKey: string | null;
}) => {
  const newAssetIcons = { ...assetIcons };
  try {
    await sendMessageToBackground({
      activePublicKey,
      assetCanonical: `${code}:${key}`,
      iconUrl: null,
      type: SERVICE_TYPES.CACHE_ASSET_ICON,
    });
  } catch (e) {
    return assetIcons;
  }
  const icon = await getIconUrlFromIssuer({ key, code, networkDetails });
  newAssetIcons[`${code}:${key}`] = icon;
  return newAssetIcons;
};

/**
 * getAssetDomains returns the home domain for a given asset issuer.
 *
 * @param assetIssuerDomainsToFetch - A list of asset issuer addresses to fetch the home domain for.
 * @param networkDetails - Network configuration details
 * @returns an object with the asset issuer address as the key and the home domain as the value.
 */
export const getAssetDomains = async ({
  assetIssuerDomainsToFetch,
  networkDetails,
}: {
  assetIssuerDomainsToFetch: string[];
  networkDetails: NetworkDetails;
}) => {
  let assetDomains = {} as { [code: string]: string };
  const filteredAssetIssuerDomainsToFetch = assetIssuerDomainsToFetch.filter(
    (domain) => StrKey.isValidEd25519PublicKey(domain),
  );
  if (filteredAssetIssuerDomainsToFetch.length === 0) {
    return assetDomains;
  }
  try {
    const fetchedAccounts = await getLedgerKeyAccounts({
      accountList: filteredAssetIssuerDomainsToFetch,
      networkDetails,
    });
    Object.entries(fetchedAccounts).forEach(([key, value]) => {
      assetDomains[key] = value.home_domain;
    });
  } catch (e) {
    captureException(`Error constructing asset domains: ${e}`);
    return {};
  }

  return assetDomains;
};

export const rejectAccess = async ({
  uuid,
}: {
  uuid: string;
}): Promise<void> => {
  try {
    await sendMessageToBackground({
      activePublicKey: null,
      uuid,
      type: SERVICE_TYPES.REJECT_ACCESS,
    });
  } catch (e) {
    console.error(e);
  }
};

export const grantAccess = async ({
  url,
  uuid,
}: {
  url: string;
  uuid: string;
}): Promise<void> => {
  try {
    await sendMessageToBackground({
      activePublicKey: null,
      url,
      uuid,
      type: SERVICE_TYPES.GRANT_ACCESS,
    });
  } catch (e) {
    console.error(e);
  }
};

export const handleSignedHwPayload = async ({
  signedPayload,
  signerAddress,
  uuid,
}: {
  signedPayload: string | Buffer;
  signerAddress?: string;
  uuid: string;
}): Promise<void> => {
  try {
    await sendMessageToBackground({
      activePublicKey: null,
      signedPayload,
      signerAddress,
      uuid,
      type: SERVICE_TYPES.HANDLE_SIGNED_HW_PAYLOAD,
    });
  } catch (e) {
    console.error(e);
  }
};

export const addToken = async ({
  activePublicKey,
  uuid,
  isTrustlineBacked,
}: {
  activePublicKey: string;
  uuid: string;
  isTrustlineBacked?: boolean;
}): Promise<void> => {
  const response = await sendMessageToBackground<{ error?: string }>({
    activePublicKey,
    uuid,
    isTrustlineBacked,
    type: SERVICE_TYPES.ADD_TOKEN,
  });

  if (response?.error) {
    throw new Error(response.error);
  }
};

export const signTransaction = async ({
  activePublicKey,
  uuid,
}: {
  activePublicKey: string;
  uuid: string;
}): Promise<void> => {
  try {
    await sendMessageToBackground({
      activePublicKey,
      uuid,
      type: SERVICE_TYPES.SIGN_TRANSACTION,
    });
  } catch (e) {
    console.error(e);
  }
};

export const signBlob = async ({
  apiVersion,
  activePublicKey,
  uuid,
}: {
  apiVersion?: string;
  activePublicKey: string;
  uuid: string;
}): Promise<void> => {
  try {
    await sendMessageToBackground({
      apiVersion,
      activePublicKey,
      uuid,
      type: SERVICE_TYPES.SIGN_BLOB,
    });
  } catch (e) {
    console.error(e);
  }
};

export const signAuthEntry = async ({
  activePublicKey,
  uuid,
}: {
  activePublicKey: string;
  uuid: string;
}): Promise<void> => {
  try {
    await sendMessageToBackground({
      activePublicKey,
      uuid,
      type: SERVICE_TYPES.SIGN_AUTH_ENTRY,
    });
  } catch (e) {
    console.error(e);
  }
};

export const signFreighterTransaction = async ({
  transactionXDR,
  network,
  activePublicKey,
}: {
  transactionXDR: string;
  network: string;
  activePublicKey: string;
}): Promise<{ signedTransaction: string }> => {
  const { signedTransaction, error } = await sendMessageToBackground({
    transactionXDR,
    network,
    activePublicKey,
    type: SERVICE_TYPES.SIGN_FREIGHTER_TRANSACTION,
  });

  if (error || !signedTransaction) {
    throw new Error(error);
  }

  return { signedTransaction };
};

export const signFreighterSorobanTransaction = async ({
  activePublicKey,
  transactionXDR,
  network,
}: {
  activePublicKey: string;
  transactionXDR: string;
  network: string;
}): Promise<{ signedTransaction: string }> => {
  const { signedTransaction, error } = await sendMessageToBackground({
    activePublicKey,
    transactionXDR,
    network,
    type: SERVICE_TYPES.SIGN_FREIGHTER_SOROBAN_TRANSACTION,
  });

  if (error || !signedTransaction) {
    throw new Error(error);
  }

  return { signedTransaction };
};

export const submitFreighterTransaction = ({
  signedXDR,
  networkDetails,
}: {
  signedXDR: string;
  networkDetails: NetworkDetails;
}) => {
  const Sdk = getSdk(networkDetails.networkPassphrase);
  const tx = Sdk.TransactionBuilder.fromXdr(
    signedXDR,
    networkDetails.networkPassphrase,
  );
  const server = stellarSdkServer(
    networkDetails.networkUrl,
    networkDetails.networkPassphrase,
  );

  return submitTx({ server, tx });
};

export const submitFreighterSorobanTransaction = async ({
  signedXDR,
  networkDetails,
}: {
  signedXDR: string;
  networkDetails: NetworkDetails;
}) => {
  let tx = {} as Transaction | FeeBumpTransaction;
  const Sdk = getSdk(networkDetails.networkPassphrase);
  try {
    tx = Sdk.TransactionBuilder.fromXdr(
      signedXDR,
      networkDetails.networkPassphrase,
    );
  } catch (e) {
    console.error(e);
  }

  if (!networkDetails.sorobanRpcUrl) {
    throw new SorobanRpcNotSupportedError();
  }

  const serverUrl = networkDetails.sorobanRpcUrl || "";

  const server = new Sdk.rpc.Server(serverUrl, {
    allowHttp: !serverUrl.startsWith("https"),
  });

  const response = await server.sendTransaction(tx);

  if (response.errorResult) {
    throw new Error(response.errorResult.result.toString());
  }

  if (response.status === SendTxStatus.Pending) {
    let txResponse = await server.getTransaction(response.hash);

    // Poll this until the status is not "NOT_FOUND"
    while (txResponse.status === GetTxStatus.NotFound) {
      // See if the transaction is complete

      txResponse = await server.getTransaction(response.hash);
      // Wait a second

      await new Promise((resolve) => setTimeout(resolve, 1000));
    }

    return response;
  } else {
    throw new Error(
      `Unabled to submit transaction, status: ${response.status}`,
    );
  }
};

export const addRecentAddress = async ({
  activePublicKey,
  address,
}: {
  activePublicKey: string;
  address: string;
}): Promise<{ recentAddresses: Array<string> }> => {
  return await sendMessageToBackground({
    activePublicKey,
    address,
    type: SERVICE_TYPES.ADD_RECENT_ADDRESS,
  });
};

export const loadRecentAddresses = async ({
  activePublicKey,
}: {
  activePublicKey: string;
}): Promise<{
  recentAddresses: Array<string>;
}> => {
  return await sendMessageToBackground({
    activePublicKey,
    type: SERVICE_TYPES.LOAD_RECENT_ADDRESSES,
  });
};

export const loadLastUsedAccount = async (): Promise<{
  lastUsedAccount: string;
}> => {
  return await sendMessageToBackground({
    activePublicKey: null,
    type: SERVICE_TYPES.LOAD_LAST_USED_ACCOUNT,
  });
};

export const signOut = async ({
  activePublicKey,
}: {
  activePublicKey: string;
}): Promise<{
  publicKey: string;
  applicationState: APPLICATION_STATE;
}> => {
  let response = {
    publicKey: "",
    applicationState: APPLICATION_STATE.MNEMONIC_PHRASE_CONFIRMED,
  };
  try {
    response = await sendMessageToBackground({
      activePublicKey,
      type: SERVICE_TYPES.SIGN_OUT,
    });
  } catch (e) {
    console.error(e);
  }

  return response;
};

export const showBackupPhrase = async ({
  activePublicKey,
  password,
}: {
  activePublicKey: string | null;
  password: string;
}): Promise<{ mnemonicPhrase: string; error: string }> => {
  let response = { mnemonicPhrase: "", error: "" };
  try {
    response = await sendMessageToBackground({
      activePublicKey,
      password,
      type: SERVICE_TYPES.SHOW_BACKUP_PHRASE,
    });
  } catch (e) {
    console.error(e);
  }

  return response;
};

export const saveAllowList = async ({
  activePublicKey,
  domain,
  networkName,
}: {
  activePublicKey: string;
  domain: string;
  networkName: string;
}): Promise<{ allowList: AllowList }> => {
  let response = {
    allowList: DEFAULT_ALLOW_LIST,
  };

  try {
    response = await sendMessageToBackground({
      activePublicKey,
      domain,
      networkName,
      type: SERVICE_TYPES.SAVE_ALLOWLIST,
    });
  } catch (e) {
    console.error(e);
  }

  return response;
};

export const saveSettings = async ({
  activePublicKey,
  isDataSharingAllowed,
  isMemoValidationEnabled,
  isHideDustEnabled,
  isOpenSidebarByDefault,
  autoLockTimeoutMinutes,
}: {
  activePublicKey: string;
  isDataSharingAllowed: boolean;
  isMemoValidationEnabled: boolean;
  isHideDustEnabled: boolean;
  isOpenSidebarByDefault: boolean;
  autoLockTimeoutMinutes: AutoLockTimeoutMinutes;
}): Promise<SaveSettingsResponse> => {
  let response: SaveSettingsResponse = {
    allowList: DEFAULT_ALLOW_LIST,
    isDataSharingAllowed: false,
    networkDetails: MAINNET_NETWORK_DETAILS,
    networksList: DEFAULT_NETWORKS,
    isMemoValidationEnabled: true,
    isRpcHealthy: false,
    isSorobanPublicEnabled: false,
    isNonSSLEnabled: false,
    isHideDustEnabled: true,
    isOpenSidebarByDefault: false,
    autoLockTimeoutMinutes: DEFAULT_AUTO_LOCK_TIMEOUT_MINUTES,
  };

  try {
    const raw = await sendMessageToBackground<
      SaveSettingsResponse | { error: string }
    >({
      activePublicKey,
      isDataSharingAllowed,
      isMemoValidationEnabled,
      isHideDustEnabled,
      isOpenSidebarByDefault,
      autoLockTimeoutMinutes,
      type: SERVICE_TYPES.SAVE_SETTINGS,
    });

    if ("error" in raw && raw.error) {
      throw new Error(raw.error);
    }

    response = raw as SaveSettingsResponse;
  } catch (e) {
    console.error(e);
  }

  return response;
};

export const saveExperimentalFeatures = async ({
  activePublicKey,
  isExperimentalModeEnabled,
  isHashSigningEnabled,
  isNonSSLEnabled,
}: {
  activePublicKey: string;
  isExperimentalModeEnabled: boolean;
  isHashSigningEnabled: boolean;
  isNonSSLEnabled: boolean;
}): Promise<ExperimentalFeatures> => {
  let response = {
    isExperimentalModeEnabled: false,
    isHashSigningEnabled: false,
    isNonSSLEnabled: false,
    networkDetails: MAINNET_NETWORK_DETAILS,
    networksList: DEFAULT_NETWORKS,
    experimentalFeaturesState: SettingsState.IDLE,
    error: "",
  };

  try {
    response = await sendMessageToBackground({
      activePublicKey,
      isExperimentalModeEnabled,
      isHashSigningEnabled,
      isNonSSLEnabled,
      type: SERVICE_TYPES.SAVE_EXPERIMENTAL_FEATURES,
    });
  } catch (e) {
    console.error(e);
  }

  return response;
};

export const getBlockaidOverrideState = async (): Promise<string | null> => {
  // Only allow override state in dev mode
  if (!isDev) {
    return null;
  }

  const response = await sendMessageToBackground({
    activePublicKey: null,
    type: SERVICE_TYPES.GET_BLOCKAID_DEBUG_OVERRIDE,
  });

  if (response.error) {
    return null;
  }

  return response.overriddenBlockaidResponse ?? null;
};

export const saveBlockaidOverrideState = async ({
  overriddenBlockaidResponse,
}: {
  overriddenBlockaidResponse: string | null;
}): Promise<{ overriddenBlockaidResponse: string | null }> => {
  const response = await sendMessageToBackground({
    activePublicKey: null,
    overriddenBlockaidResponse,
    type: SERVICE_TYPES.SAVE_BLOCKAID_DEBUG_OVERRIDE,
  });

  if (response.error) {
    throw new Error(response.error);
  }

  return {
    overriddenBlockaidResponse: response.overriddenBlockaidResponse ?? null,
  };
};

export const changeNetwork = async ({
  activePublicKey,
  networkName,
}: {
  activePublicKey: string;
  networkName: string;
}): Promise<{ networkDetails: NetworkDetails; isRpcHealthy: boolean }> => {
  let networkDetails = MAINNET_NETWORK_DETAILS;
  let isRpcHealthy = false;
  let error = "";

  try {
    ({ networkDetails, isRpcHealthy, error } = await sendMessageToBackground({
      activePublicKey,
      networkName,
      type: SERVICE_TYPES.CHANGE_NETWORK,
    }));
  } catch (e) {
    console.error(e);
  }

  if (error) {
    throw new Error(error);
  }

  return { networkDetails, isRpcHealthy };
};

export const addCustomNetwork = async ({
  activePublicKey,
  networkDetails,
}: {
  activePublicKey: string;
  networkDetails: NetworkDetails;
}): Promise<{
  networksList: NetworkDetails[];
}> => {
  let response = {
    error: "",
    networksList: [] as NetworkDetails[],
  };

  try {
    response = await sendMessageToBackground({
      activePublicKey,
      networkDetails,
      type: SERVICE_TYPES.ADD_CUSTOM_NETWORK,
    });
  } catch (e) {
    console.error(e);
  }

  if (response.error) {
    throw new Error(response.error);
  }

  return response;
};

export const removeCustomNetwork = async ({
  activePublicKey,
  networkName,
}: {
  activePublicKey: string;
  networkName: string;
}) => {
  let response = {
    networkDetails: MAINNET_NETWORK_DETAILS,
    networksList: [] as NetworkDetails[],
    error: "",
  };

  try {
    response = await sendMessageToBackground({
      activePublicKey,
      networkName,
      type: SERVICE_TYPES.REMOVE_CUSTOM_NETWORK,
    });
  } catch (e) {
    console.error(e);
  }

  if (response.error) {
    throw new Error(response.error);
  }

  return response;
};

export const editCustomNetwork = async ({
  activePublicKey,
  networkDetails,
  networkIndex,
}: {
  activePublicKey: string;
  networkDetails: NetworkDetails;
  networkIndex: number;
}) => {
  let response = {
    networkDetails: MAINNET_NETWORK_DETAILS,
    networksList: [] as NetworkDetails[],
    error: "",
  };

  try {
    response = await sendMessageToBackground({
      activePublicKey,
      networkDetails,
      networkIndex,
      type: SERVICE_TYPES.EDIT_CUSTOM_NETWORK,
    });
  } catch (e) {
    console.error(e);
  }

  if (response.error) {
    throw new Error(response.error);
  }

  return response;
};

export const loadSettings = (): Promise<
  Settings &
    IndexerSettings &
    ExperimentalFeatures & { assetsLists: AssetsLists }
> =>
  sendMessageToBackground<
    Settings &
      IndexerSettings &
      ExperimentalFeatures & { assetsLists: AssetsLists }
  >({
    activePublicKey: null,
    type: SERVICE_TYPES.LOAD_SETTINGS,
  });

export const loadBackendSettings = async (): Promise<{
  isSorobanPublicEnabled: boolean;
  isRpcHealthy: boolean;
  userNotification: UserNotification;
}> => {
  return await sendMessageToBackground({
    activePublicKey: null,
    type: SERVICE_TYPES.LOAD_BACKEND_SETTINGS,
  });
};

export const getMemoRequiredAccounts = async ({
  activePublicKey,
}: {
  activePublicKey: string;
}) => {
  const resp = await sendMessageToBackground({
    activePublicKey,
    type: SERVICE_TYPES.GET_MEMO_REQUIRED_ACCOUNTS,
  });
  return resp;
};

export const addTokenId = async ({
  activePublicKey,
  publicKey,
  tokenId,
  network,
}: {
  activePublicKey: string;
  publicKey: string;
  tokenId: string;
  network: Networks;
}): Promise<{
  tokenIdList: string[];
}> => {
  let error = "";
  let tokenIdList = [] as string[];

  try {
    ({ tokenIdList, error } = await sendMessageToBackground({
      activePublicKey,
      publicKey,
      tokenId,
      network,
      type: SERVICE_TYPES.ADD_TOKEN_ID,
    }));
  } catch (e) {
    console.error(e);
  }

  if (error) {
    throw new Error(error);
  }

  return { tokenIdList };
};

export const getTokenIds = async ({
  activePublicKey,
  network,
}: {
  activePublicKey: string;
  network: NETWORKS;
}): Promise<string[]> => {
  const { tokenIdList, error } = await sendMessageToBackground({
    activePublicKey,
    type: SERVICE_TYPES.GET_TOKEN_IDS,
    network,
  });

  if (error) {
    return [];
  }

  return tokenIdList;
};

export const removeTokenId = async ({
  activePublicKey,
  contractId,
  network,
}: {
  activePublicKey: string;
  contractId: string;
  network: NETWORKS;
}): Promise<string[]> => {
  const resp = await sendMessageToBackground({
    type: SERVICE_TYPES.REMOVE_TOKEN_ID,
    contractId,
    network,
    activePublicKey,
  });
  return resp.tokenIdList;
};

export const addAssetsList = async ({
  activePublicKey,
  assetsList,
  network,
}: {
  activePublicKey: string;
  assetsList: AssetsListItem;
  network: NETWORKS;
}) => {
  let response = {
    error: "",
    assetsLists: {} as AssetsLists,
  };

  response = await sendMessageToBackground({
    type: SERVICE_TYPES.ADD_ASSETS_LIST,
    assetsList,
    network,
    activePublicKey,
  });

  return { assetsLists: response.assetsLists, error: response.error };
};

export const modifyAssetsList = async ({
  activePublicKey,
  assetsList,
  network,
  isDeleteAssetsList,
}: {
  activePublicKey: string;
  assetsList: AssetsListItem;
  network: NETWORKS;
  isDeleteAssetsList: boolean;
}) => {
  let response = {
    error: "",
    assetsLists: {} as AssetsLists,
  };

  response = await sendMessageToBackground({
    type: SERVICE_TYPES.MODIFY_ASSETS_LIST,
    assetsList,
    network,
    isDeleteAssetsList,
    activePublicKey,
  });

  return { assetsLists: response.assetsLists, error: response.error };
};

export const simulateSendCollectible = async (args: {
  collectionAddress: string;
  publicKey: string;
  params: {
    publicKey: string;
    destination: string;
    collectionAddress: string;
    tokenId: number;
  };
  networkDetails: NetworkDetails;
  transactionFee: string;
}): Promise<{
  ok: boolean;
  response: {
    preparedTransaction: string;
    simulationResponse: SorobanRpc.Api.SimulateTransactionSuccessResponse;
  };
}> => {
  const {
    collectionAddress,
    publicKey,
    params,
    networkDetails,
    transactionFee,
  } = args;
  if (!networkDetails.sorobanRpcUrl) {
    throw new SorobanRpcNotSupportedError();
  }
  const server = stellarSdkServer(
    networkDetails.networkUrl,
    networkDetails.networkPassphrase,
  );
  const Sdk = getSdk(networkDetails.networkPassphrase);
  const sourceAccount = await server.loadAccount(publicKey);
  const builder = new Sdk.TransactionBuilder(sourceAccount, {
    fee: xlmToStroop(transactionFee).toFixed(),
    networkPassphrase: networkDetails.networkPassphrase,
  });

  const sendCollectibleParams = [
    new Address(publicKey).toScVal(), // from
    new Address(params.destination).toScVal(), // to
    xdr.ScVal.scvU32(params.tokenId), // token id
  ];
  const transaction = transfer(
    collectionAddress,
    sendCollectibleParams,
    undefined,
    builder,
  );

  const simulationResponse = (await simulateTransaction({
    xdr: transaction.toXdr(),
    networkDetails: networkDetails,
  })) as {
    ok: boolean;
    response: {
      preparedTransaction: string;
      simulationResponse: SorobanRpc.Api.SimulateTransactionSuccessResponse;
    };
  };

  return simulationResponse;
};

export const simulateTokenTransfer = async (args: {
  address: string;
  publicKey: string;
  memo?: string;
  params: {
    publicKey: string;
    destination: string;
    amount: number;
  };
  networkDetails: NetworkDetails;
  transactionFee: string;
}): Promise<{
  ok: boolean;
  response: {
    preparedTransaction: string;
    simulationResponse: SorobanRpc.Api.SimulateTransactionSuccessResponse;
  };
}> => {
  const { address, publicKey, memo, params, networkDetails, transactionFee } =
    args;

  if (isCustomNetwork(networkDetails)) {
    if (!networkDetails.sorobanRpcUrl) {
      throw new SorobanRpcNotSupportedError();
    }
    const server = buildSorobanServer(
      networkDetails.sorobanRpcUrl,
      networkDetails.networkPassphrase,
    );
    const builder = await getNewTxBuilder(
      publicKey,
      networkDetails,
      server,
      xlmToStroop(transactionFee).toFixed(),
    );

    const transferParams = [
      new Address(publicKey).toScVal(), // from
      new Address(params.destination).toScVal(), // to (may be muxed address)
      new XdrLargeInt("i128", params.amount).toI128(), // amount
    ];
    const transaction = transfer(address, transferParams, memo, builder);
    // TODO: type narrow instead of cast
    const simulationResponse = (await server.simulateTransaction(
      transaction,
    )) as SorobanRpc.Api.SimulateTransactionSuccessResponse;

    const preparedTransaction = SorobanRpc.assembleTransaction(
      transaction,
      simulationResponse,
    )
      .build()
      .toXdr();

    return {
      ok: true,
      response: {
        simulationResponse,
        preparedTransaction,
      },
    };
  }

  // Build request body - ensure memo is a string (empty string if undefined/null for muxed addresses)
  const requestBody: {
    address: string;
    pub_key: string;
    memo: string;
    fee: string;
    params: {
      publicKey: string;
      destination: string;
      amount: number;
    };
    network_passphrase: string;
  } = {
    address,
    pub_key: publicKey,
    memo: memo || "", // Backend requires memo as string, use empty string if undefined
    fee: xlmToStroop(transactionFee).toFixed(),
    params,
    network_passphrase: networkDetails.networkPassphrase,
  };

  const options = {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify(requestBody),
  };
  const res = await fetch(`${INDEXER_URL}/simulate-token-transfer`, options);
  const response = await res.json();
  return {
    ok: res.ok,
    response,
  };
};

export const simulateTransaction = async (args: {
  xdr: string;
  networkDetails: NetworkDetails;
}) => {
  const { xdr, networkDetails } = args;
  const options = {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      xdr,
      network_passphrase: networkDetails.networkPassphrase,
    }),
  };
  const res = await fetch(`${INDEXER_URL}/simulate-tx`, options);
  const response = await res.json();
  return {
    ok: res.ok,
    response,
  };
};

export const getIsAccountMismatch = async ({
  activePublicKey,
}: {
  activePublicKey: string;
}) => {
  let response = {
    error: "",
    isAccountMismatch: false,
  };

  response = await sendMessageToBackground({
    type: SERVICE_TYPES.GET_IS_ACCOUNT_MISMATCH,
    activePublicKey,
  });

  if (response.error) {
    throw new Error(response.error);
  }

  return {
    isAccountMismatch: response.isAccountMismatch,
    error: response.error,
  };
};

export const getHiddenAssets = async ({
  activePublicKey,
}: {
  activePublicKey: string;
}) => {
  let response = {
    error: "",
    hiddenAssets: {} as Record<IssuerKey, AssetVisibility>,
  };

  response = await sendMessageToBackground({
    type: SERVICE_TYPES.GET_HIDDEN_ASSETS,
    activePublicKey,
  });

  return { hiddenAssets: response.hiddenAssets || {}, error: response.error };
};

export const changeAssetVisibility = async ({
  assetIssuer,
  assetVisibility,
  activePublicKey,
}: {
  assetIssuer: IssuerKey;
  assetVisibility: AssetVisibility;
  activePublicKey: string;
}) => {
  let response = {
    error: "",
    hiddenAssets: {} as Record<IssuerKey, AssetVisibility>,
  };

  response = await sendMessageToBackground({
    type: SERVICE_TYPES.CHANGE_ASSET_VISIBILITY,
    assetVisibility: {
      issuer: assetIssuer,
      visibility: assetVisibility,
    },
    activePublicKey,
  });

  return { hiddenAssets: response.hiddenAssets, error: response.error };
};

export const addCollectible = async ({
  publicKey,
  network,
  collectibleContractAddress,
  collectibleTokenId,
}: {
  publicKey: string;
  network: string;
  collectibleContractAddress: string;
  collectibleTokenId: string;
}) => {
  let response = {
    error: "",
    collectiblesList: [] as CollectibleContract[],
  };

  try {
    response = await sendMessageToBackground({
      type: SERVICE_TYPES.ADD_COLLECTIBLE,
      activePublicKey: publicKey,
      publicKey,
      network,
      collectibleContractAddress,
      collectibleTokenId,
    });
  } catch (e) {
    console.error(e);
  }

  return response;
};

export const getCollectibles = async ({
  publicKey,
  network,
}: {
  publicKey: string;
  network: string;
}) => {
  let response = {
    error: "",
    collectiblesList: [] as CollectibleContract[],
  };

  try {
    response = await sendMessageToBackground({
      type: SERVICE_TYPES.GET_COLLECTIBLES,
      activePublicKey: publicKey,
      publicKey,
      network,
    });
  } catch (e) {
    console.error(e);
  }

  return response;
};

export const changeCollectibleVisibility = async ({
  collectibleKey,
  collectibleVisibility,
  activePublicKey,
}: {
  collectibleKey: string;
  collectibleVisibility: AssetVisibility;
  activePublicKey: string;
}) => {
  const response = await sendMessageToBackground({
    type: SERVICE_TYPES.CHANGE_COLLECTIBLE_VISIBILITY,
    collectibleVisibility: {
      collectible: collectibleKey,
      visibility: collectibleVisibility,
    },
    activePublicKey,
  });

  return {
    hiddenCollectibles: response?.hiddenCollectibles || {},
    error: response?.error || "",
  };
};

export const getHiddenCollectibles = async ({
  activePublicKey,
}: {
  activePublicKey: string;
}) => {
  const response = await sendMessageToBackground({
    type: SERVICE_TYPES.GET_HIDDEN_COLLECTIBLES,
    activePublicKey,
  });

  return {
    hiddenCollectibles: response?.hiddenCollectibles || {},
    error: response?.error || "",
  };
};

export const markQueueActive = async ({
  uuid,
  isActive,
}: {
  uuid: string;
  isActive: boolean;
}): Promise<void> => {
  try {
    await sendMessageToBackground({
      activePublicKey: null,
      uuid,
      isActive,
      type: SERVICE_TYPES.MARK_QUEUE_ACTIVE,
    });
  } catch (e) {
    console.error(e);
  }
};

export const rejectSigningRequest = async ({
  uuid,
}: {
  uuid: string;
}): Promise<void> => {
  try {
    await sendMessageToBackground({
      activePublicKey: null,
      uuid,
      type: SERVICE_TYPES.REJECT_SIGNING_REQUEST,
    });
  } catch (e) {
    console.error(e);
  }
};

export const getRecentProtocols = async (): Promise<RecentProtocolEntry[]> => {
  const { recentProtocols, error } = await sendMessageToBackground({
    activePublicKey: null,
    type: SERVICE_TYPES.GET_RECENT_PROTOCOLS,
  });

  if (error) {
    return [];
  }

  return recentProtocols || [];
};

export const addRecentProtocol = async (
  websiteUrl: string,
): Promise<RecentProtocolEntry[]> => {
  const { recentProtocols, error } = await sendMessageToBackground({
    activePublicKey: null,
    websiteUrl,
    type: SERVICE_TYPES.ADD_RECENT_PROTOCOL,
  });

  if (error) {
    throw new Error(error);
  }

  return recentProtocols || [];
};

export const clearRecentProtocols = async (): Promise<
  RecentProtocolEntry[]
> => {
  const { recentProtocols, error } = await sendMessageToBackground({
    activePublicKey: null,
    type: SERVICE_TYPES.CLEAR_RECENT_PROTOCOLS,
  });

  if (error) {
    throw new Error(error);
  }

  return recentProtocols || [];
};

export const getHasSeenDiscoverWelcome = async (): Promise<boolean> => {
  const { hasSeenDiscoverWelcome, error } = await sendMessageToBackground({
    activePublicKey: null,
    type: SERVICE_TYPES.GET_DISCOVER_WELCOME_SEEN,
  });

  if (error) {
    throw new Error(error);
  }

  return !!hasSeenDiscoverWelcome;
};

export const dismissDiscoverWelcome = async (): Promise<boolean> => {
  const { hasSeenDiscoverWelcome, error } = await sendMessageToBackground({
    activePublicKey: null,
    type: SERVICE_TYPES.DISMISS_DISCOVER_WELCOME,
  });

  if (error) {
    throw new Error(error);
  }

  return !!hasSeenDiscoverWelcome;
};

export const getCachedSwapTopTokens = async (
  network: string,
): Promise<{ tokens: TrendingAsset[]; updatedAt: number } | null> => {
  const { cachedSwapTopTokens, error } = await sendMessageToBackground({
    activePublicKey: null,
    type: SERVICE_TYPES.GET_CACHED_SWAP_TOP_TOKENS,
    network,
  });

  if (error) {
    throw new Error(error);
  }

  return cachedSwapTopTokens || null;
};

export const cacheSwapTopTokens = async (
  network: string,
  tokens: TrendingAsset[],
): Promise<void> => {
  const { error } = await sendMessageToBackground({
    activePublicKey: null,
    type: SERVICE_TYPES.CACHE_SWAP_TOP_TOKENS,
    network,
    tokens,
  });

  if (error) {
    throw new Error(error);
  }
};