Account and Balance Errors

const AccountNameRequiredError: CustomErrorFunc;
const AccountNotSupported: CustomErrorFunc;
const WrongDeviceForAccount: CustomErrorFunc;
const NoAddressesFound: CustomErrorFunc;

import { 
  AccountNameRequiredError,
  AccountNotSupported,
  WrongDeviceForAccount,
  NoAddressesFound
} from "@ledgerhq/errors";

// Account name is required
throw new AccountNameRequiredError("Account name must be provided");

// Account type not supported
throw new AccountNotSupported("This account type is not supported for the selected currency");

// Wrong device for this account
throw new WrongDeviceForAccount("This account belongs to a different Ledger device");

// No addresses found for account
throw new NoAddressesFound("No addresses found for this account");

const NotEnoughBalance: CustomErrorFunc;
const NotEnoughBalanceToDelegate: CustomErrorFunc;
const NotEnoughBalanceInParentAccount: CustomErrorFunc;
const NotEnoughSpendableBalance: CustomErrorFunc;
const NotEnoughBalanceBecauseDestinationNotCreated: CustomErrorFunc;

import { 
  NotEnoughBalance,
  NotEnoughBalanceToDelegate,
  NotEnoughBalanceInParentAccount,
  NotEnoughSpendableBalance,
  NotEnoughBalanceBecauseDestinationNotCreated
} from "@ledgerhq/errors";

// Insufficient balance for transaction
throw new NotEnoughBalance("Insufficient balance to complete transaction", {
  available: "0.001 BTC",
  required: "0.005 BTC"
});

// Insufficient balance for delegation
throw new NotEnoughBalanceToDelegate("Insufficient balance to delegate stake", {
  available: "100 XTZ",
  minimumRequired: "200 XTZ"
});

// Parent account has insufficient balance
throw new NotEnoughBalanceInParentAccount("Parent account does not have enough balance");

// Insufficient spendable balance (excluding locked/reserved amounts)
throw new NotEnoughSpendableBalance("Insufficient spendable balance", {
  totalBalance: "1.0 ETH",
  spendableBalance: "0.1 ETH",
  required: "0.5 ETH"
});

// Destination account needs to be created first
throw new NotEnoughBalanceBecauseDestinationNotCreated(
  "Destination account must be created with minimum balance", 
  {
    minimumRequired: "1 XRP"
  }
);

const NotEnoughGas: CustomErrorFunc;
const GasLessThanEstimate: CustomErrorFunc;

import { 
  NotEnoughGas,
  GasLessThanEstimate
} from "@ledgerhq/errors";

// Insufficient gas for Ethereum transaction
throw new NotEnoughGas("Insufficient gas to complete transaction", {
  gasRequired: "21000",
  gasAvailable: "15000",
  gasPriceGwei: "20"
});

// Gas amount is less than the estimated requirement
throw new GasLessThanEstimate("Gas amount is below the estimated requirement", {
  providedGas: "15000",
  estimatedGas: "21000"
});

const RecommendUndelegation: CustomErrorFunc;
const RecommendSubAccountsToEmpty: CustomErrorFunc;

import { 
  RecommendUndelegation,
  RecommendSubAccountsToEmpty
} from "@ledgerhq/errors";

// Recommend undelegation before performing operation
throw new RecommendUndelegation("Consider undelegating before performing this operation", {
  delegatedAmount: "500 XTZ",
  validator: "tz1abc123..."
});

// Recommend emptying sub-accounts first
throw new RecommendSubAccountsToEmpty("Consider emptying sub-accounts before closing main account", {
  subAccountCount: 3,
  totalSubAccountBalance: "0.05 BTC"
});

const UnavailableTezosOriginatedAccountReceive: CustomErrorFunc;
const UnavailableTezosOriginatedAccountSend: CustomErrorFunc;
const CashAddrNotSupported: CustomErrorFunc;
const NotSupportedLegacyAddress: CustomErrorFunc;

import { 
  UnavailableTezosOriginatedAccountReceive,
  UnavailableTezosOriginatedAccountSend,
  CashAddrNotSupported,
  NotSupportedLegacyAddress
} from "@ledgerhq/errors";

// Tezos originated account cannot receive
throw new UnavailableTezosOriginatedAccountReceive(
  "Cannot receive funds on Tezos originated account"
);

// Tezos originated account cannot send
throw new UnavailableTezosOriginatedAccountSend(
  "Cannot send funds from Tezos originated account"
);

// Bitcoin Cash address format not supported
throw new CashAddrNotSupported("Bitcoin Cash address format is not supported");

// Legacy address format not supported
throw new NotSupportedLegacyAddress("Legacy address format is not supported for this operation");

const CurrencyNotSupported: CustomErrorFunc;

import { CurrencyNotSupported } from "@ledgerhq/errors";

// Currency not supported by device or app
throw new CurrencyNotSupported("This cryptocurrency is not supported", {
  requestedCurrency: "DOGE",
  supportedCurrencies: ["BTC", "ETH", "XRP", "LTC"]
});

// Currency not supported for specific operation
throw new CurrencyNotSupported("Currency not supported for staking", {
  currency: "BTC",
  operation: "staking"
});

type CustomErrorFunc = (
  message?: string,
  fields?: { [key: string]: any }
) => void;