@swapkit/wallets 3.0.0-beta.20 → 3.0.0-beta.21

package/src/keepkey/chains/cosmos.ts

@@ -21,64 +21,58 @@ export const cosmosWalletMethods = async ({
     getFeeRateFromThorswap,
     createStargateClient,
   } = await import("@swapkit/toolboxes/cosmos");
+  const derivationPathString = derivationPath
+    ? derivationPathToString(derivationPath)
+    : `${DerivationPath.GAIA}/0`;
 
-  try {
-    const derivationPathString = derivationPath
-      ? derivationPathToString(derivationPath)
-      : `${DerivationPath.GAIA}/0`;
+  const { address: fromAddress } = (await sdk.address.cosmosGetAddress({
+    address_n: bip32ToAddressNList(derivationPathString),
+  })) as { address: string };
 
-    const { address: fromAddress } = (await sdk.address.cosmosGetAddress({
-      address_n: bip32ToAddressNList(derivationPathString),
-    })) as { address: string };
+  const toolbox = await getCosmosToolbox(Chain.Cosmos);
 
-    const toolbox = await getCosmosToolbox(Chain.Cosmos);
-
-    if (DEFAULT_COSMOS_FEE_MAINNET.amount[0]) {
-      DEFAULT_COSMOS_FEE_MAINNET.amount[0].amount = String(
-        await getFeeRateFromThorswap(ChainId.Cosmos, 500),
-      );
-    }
+  if (DEFAULT_COSMOS_FEE_MAINNET.amount[0]) {
+    DEFAULT_COSMOS_FEE_MAINNET.amount[0].amount = String(
+      await getFeeRateFromThorswap(ChainId.Cosmos, 500),
+    );
+  }
 
-    // TODO support other cosmos assets
-    const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
-      const amount = assetValue.getBaseValue("string");
-      const accountInfo = await toolbox.getAccount(fromAddress);
+  // TODO support other cosmos assets
+  const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
+    const amount = assetValue.getBaseValue("string");
+    const accountInfo = await toolbox.getAccount(fromAddress);
 
-      const keepKeySignedTx = await sdk.cosmos.cosmosSignAmino({
-        signerAddress: fromAddress,
-        signDoc: {
-          fee: DEFAULT_COSMOS_FEE_MAINNET,
-          memo: memo || "",
-          sequence: accountInfo?.sequence.toString() ?? "",
-          chain_id: ChainId.Cosmos,
-          account_number: accountInfo?.accountNumber.toString() ?? "",
-          msgs: [
-            {
-              value: {
-                amount: [{ denom: "uatom", amount }],
-                to_address: recipient,
-                from_address: fromAddress,
-              },
-              type: "cosmos-sdk/MsgSend",
+    const keepKeySignedTx = await sdk.cosmos.cosmosSignAmino({
+      signerAddress: fromAddress,
+      signDoc: {
+        fee: DEFAULT_COSMOS_FEE_MAINNET,
+        memo: memo || "",
+        sequence: accountInfo?.sequence.toString() ?? "",
+        chain_id: ChainId.Cosmos,
+        account_number: accountInfo?.accountNumber.toString() ?? "",
+        msgs: [
+          {
+            value: {
+              amount: [{ denom: "uatom", amount }],
+              to_address: recipient,
+              from_address: fromAddress,
             },
-          ],
-        },
-      });
+            type: "cosmos-sdk/MsgSend",
+          },
+        ],
+      },
+    });
 
-      const decodedBytes = atob(keepKeySignedTx.serialized);
-      const uint8Array = new Uint8Array(decodedBytes.length).map((_, i) =>
-        decodedBytes.charCodeAt(i),
-      );
+    const decodedBytes = atob(keepKeySignedTx.serialized);
+    const uint8Array = new Uint8Array(decodedBytes.length).map((_, i) =>
+      decodedBytes.charCodeAt(i),
+    );
 
-      const client = await createStargateClient(SKConfig.get("rpcUrls")[Chain.Cosmos]);
-      const response = await client.broadcastTx(uint8Array);
+    const client = await createStargateClient(SKConfig.get("rpcUrls")[Chain.Cosmos]);
+    const response = await client.broadcastTx(uint8Array);
 
-      return response.transactionHash;
-    };
+    return response.transactionHash;
+  };
 
-    return { ...toolbox, transfer, address: fromAddress };
-  } catch (e) {
-    console.error(e);
-    throw e;
-  }
+  return { ...toolbox, transfer, address: fromAddress };
 };

package/src/keepkey/chains/evm.ts

@@ -4,6 +4,7 @@ import {
   ChainToChainId,
   type DerivationPathArray,
   NetworkDerivationPath,
+  SwapKitError,
   derivationPathToString,
 } from "@swapkit/helpers";
 import type { JsonRpcProvider, Provider, TransactionRequest } from "ethers";
@@ -35,7 +36,7 @@ export class KeepKeySigner extends AbstractSigner {
   }
 
   signTypedData(): Promise<string> {
-    throw new Error("this method is not implemented");
+    throw new SwapKitError("wallet_keepkey_method_not_supported", { method: "signTypedData" });
   }
 
   getAddress = async () => {
@@ -62,14 +63,21 @@ export class KeepKeySigner extends AbstractSigner {
     gasPrice,
     // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
   }: TransactionRequest) => {
-    if (!to) throw new Error("Missing to address");
-    if (!gasLimit) throw new Error("Missing gasLimit");
-    if (!data) throw new Error("Missing data");
+    if (!to)
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing to address" });
+    if (!gasLimit)
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing gasLimit" });
+    if (!data) throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing data" });
 
     const isEIP1559 = !!((maxFeePerGas || maxPriorityFeePerGas) && !gasPrice);
-    if (isEIP1559 && !maxFeePerGas) throw new Error("Missing maxFeePerGas");
-    if (isEIP1559 && !maxPriorityFeePerGas) throw new Error("Missing maxFeePerGas");
-    if (!(isEIP1559 || gasPrice)) throw new Error("Missing gasPrice");
+    if (isEIP1559 && !maxFeePerGas)
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing maxFeePerGas" });
+    if (isEIP1559 && !maxPriorityFeePerGas)
+      throw new SwapKitError("wallet_keepkey_invalid_params", {
+        reason: "Missing maxPriorityFeePerGas",
+      });
+    if (!(isEIP1559 || gasPrice))
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing gasPrice" });
 
     const { toHexString } = await import("@swapkit/toolboxes/evm");
 
@@ -100,7 +108,7 @@ export class KeepKeySigner extends AbstractSigner {
   };
 
   sendTransaction = async (tx: TransactionRequest): Promise<any> => {
-    if (!this.provider) throw new Error("No provider set");
+    if (!this.provider) throw new SwapKitError("wallet_keepkey_no_provider");
 
     const signedTxHex = await this.signTransaction(tx);
 

package/src/keepkey/chains/mayachain.ts

@@ -7,6 +7,7 @@ import {
   type DerivationPathArray,
   type GenericTransferParams,
   SKConfig,
+  SwapKitError,
   derivationPathToString,
 } from "@swapkit/helpers";
 import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
@@ -48,7 +49,7 @@ export const mayachainWalletMethods = async ({
     const { getDenomWithChain } = await import("@swapkit/toolboxes/cosmos");
 
     const account = await toolbox.getAccount(sender);
-    if (!account) throw new Error("Account not found");
+    if (!account) throw new SwapKitError("wallet_keepkey_account_not_found");
     const { accountNumber, sequence = 0 } = account;
     const amount = assetValue.getBaseValue("string");
 

package/src/keepkey/chains/thorchain.ts

@@ -11,6 +11,7 @@ import {
   type DerivationPathArray,
   type GenericTransferParams,
   SKConfig,
+  SwapKitError,
   derivationPathToString,
 } from "@swapkit/helpers";
 import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
@@ -51,7 +52,7 @@ export const thorchainWalletMethods = async ({
     memo,
   }: SignTransactionParams) => {
     const account = await toolbox.getAccount(sender);
-    if (!account) throw new Error("Account not found");
+    if (!account) throw new SwapKitError("wallet_keepkey_account_not_found");
     const { accountNumber, sequence = 0 } = account;
 
     const isTransfer = recipient && recipient !== "";

package/src/keepkey/chains/utxo.ts

@@ -5,6 +5,7 @@ import {
   type DerivationPathArray,
   FeeOption,
   type GenericTransferParams,
+  SwapKitError,
   type UTXOChain,
   derivationPathToString,
 } from "@swapkit/helpers";
@@ -101,8 +102,14 @@ export const utxoWalletMethods = async ({
     memo,
     ...rest
   }: GenericTransferParams) => {
-    if (!walletAddress) throw new Error("From address must be provided");
-    if (!recipient) throw new Error("Recipient address must be provided");
+    if (!walletAddress)
+      throw new SwapKitError("wallet_keepkey_invalid_params", {
+        reason: "From address must be provided",
+      });
+    if (!recipient)
+      throw new SwapKitError("wallet_keepkey_invalid_params", {
+        reason: "Recipient address must be provided",
+      });
 
     const createTxMethod =
       chain === Chain.BitcoinCash

package/src/keepkey/coins.ts

@@ -2,6 +2,8 @@
     KeepKey Specific bip32 path conventions
 */
 
+import { SwapKitError } from "@swapkit/helpers";
+
 const HARDENED = 0x80000000;
 
 export enum ChainToKeepKeyName {
@@ -27,7 +29,9 @@ export function bip32ToAddressNList(initPath: string): number[] {
   let path = initPath;
 
   if (!bip32Like(path)) {
-    throw new Error(`Not a bip32 path: '${path}'`);
+    throw new SwapKitError("wallet_keepkey_invalid_params", {
+      reason: `Not a bip32 path: '${path}'`,
+    });
   }
 
   if (/^m\//i.test(path)) {
@@ -44,18 +48,20 @@ export function bip32ToAddressNList(initPath: string): number[] {
     const segment = segments[i];
     if (segment) {
       const tmp = /(\d+)([hH']?)/.exec(segment);
-      if (tmp === null) throw new Error("Invalid input");
+      if (tmp === null)
+        throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid input" });
 
       const [, num = "", modifier = ""] = tmp;
 
       ret[i] = Number.parseInt(num, 10);
 
-      if (ret[i] >= HARDENED) throw new Error("Invalid child index");
+      if (ret[i] >= HARDENED)
+        throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid child index" });
 
       if (modifier === "h" || modifier === "H" || modifier === "'") {
         ret[i] += HARDENED;
       } else if (modifier.length > 0) {
-        throw new Error("Invalid modifier");
+        throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid modifier" });
       }
     }
   }

package/src/keepkey/index.ts

@@ -3,6 +3,7 @@ import {
   type DerivationPathArray,
   NetworkDerivationPath,
   SKConfig,
+  SwapKitError,
   WalletOption,
   createWallet,
   filterSupportedChains,
@@ -44,15 +45,22 @@ export const keepkeyWallet = createWallet({
       derivationPathMap?: Record<Chain, DerivationPathArray>,
     ) {
       const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-      const config = SKConfig.get("integrations").keepKey;
+      const pairingInfo = SKConfig.get("integrations").keepKey;
+      if (!pairingInfo) throw new Error("KeepKey config not found");
 
-      if (!config) throw new Error("KeepKey config not found");
+      const initialApiKey = SKConfig.get("apiKeys").keepKey || "1234";
 
       await checkAndLaunch();
 
-      const keepkeyConfig = { ...config, apiKey: SKConfig.get("apiKeys").keepKey };
+      // Conform to the expected { apiKey, pairingInfo } structure
+      const keepkeyConfig = { apiKey: initialApiKey, pairingInfo };
       const keepKeySdk = await KeepKeySdk.create(keepkeyConfig);
 
+      // Persist the new API key via SKConfig after pairing
+      if (keepkeyConfig.apiKey && keepkeyConfig.apiKey !== initialApiKey) {
+        SKConfig.setApiKey("keepKey", keepkeyConfig.apiKey);
+      }
+
       await Promise.all(
         filteredChains.map(async (chain) => {
           const walletMethods = await getWalletMethods({
@@ -84,6 +92,7 @@ async function getWalletMethods({
     case Chain.Optimism:
     case Chain.Polygon:
     case Chain.Avalanche:
+    case Chain.Base:
     case Chain.Ethereum: {
       const provider = await getProvider(chain);
       const signer = new KeepKeySigner({ sdk, chain, derivationPath, provider });
@@ -108,11 +117,11 @@ async function getWalletMethods({
       return utxoWalletMethods({ sdk, chain, derivationPath });
     }
     default:
-      throw new Error(`Chain not supported ${chain}`);
+      throw new SwapKitError("wallet_keepkey_chain_not_supported", { chain });
   }
 }
 
-// kk-sdk docs: https://medium.com/@highlander_35968/building-on-the-keepkey-sdk-2023fda41f38
+// kk-sdk docs: https://keepkey.com/blog/building_on_the_keepkey_sdk
 // test spec: if offline, launch keepkey-bridge
 async function checkAndLaunch(attempts = 0) {
   if (attempts >= 3) {
@@ -133,8 +142,7 @@ async function checkKeepkeyAvailability(spec = "http://localhost:1646/spec/swagg
   try {
     const response = await fetch(spec);
     return response.status === 200;
-  } catch (error) {
-    console.error(error);
+  } catch (_error) {
     return false;
   }
 }

package/src/keepkey-bex/index.ts

@@ -83,11 +83,11 @@ async function getWalletMethods(chain: (typeof KEEPKEY_BEX_SUPPORTED_CHAINS)[num
 
       // @ts-expect-error assumed available connection
       const signer = window.keepkey?.cosmos?.getOfflineSignerOnlyAmino(ChainIdToChain[chain]);
-      if (!signer) throw new Error("Could not load signer");
+      if (!signer) throw new SwapKitError("wallet_keepkey_signer_not_found");
       const toolbox = getCosmosToolbox(chain, { signer });
 
       const accounts = await signer.getAccounts();
-      if (!accounts?.[0]?.address) throw new Error("No accounts found");
+      if (!accounts?.[0]?.address) throw new SwapKitError("wallet_keepkey_no_accounts");
 
       const [{ address }] = accounts;
 
@@ -103,18 +103,13 @@ async function getWalletMethods(chain: (typeof KEEPKEY_BEX_SUPPORTED_CHAINS)[num
       const toolbox = await getUtxoToolbox(chain);
 
       const getBalance = async () => {
-        try {
-          const providerChain = getProviderNameFromChain(chain);
-          // @ts-expect-error We assuming there chains via switch
-          const balance = await window?.keepkey?.[providerChain]?.request({
-            method: "request_balance",
-          });
-          const assetValue = AssetValue.from({ chain, value: balance[0].balance });
-          return [assetValue];
-        } catch (error) {
-          console.error("Error fetching balance:", error);
-          throw error;
-        }
+        const providerChain = getProviderNameFromChain(chain);
+        // @ts-expect-error We assuming there chains via switch
+        const balance = await window?.keepkey?.[providerChain]?.request({
+          method: "request_balance",
+        });
+        const assetValue = AssetValue.from({ chain, value: balance[0].balance });
+        return [assetValue];
       };
 
       return { ...toolbox, getBalance, transfer: walletTransfer };

package/src/keepkey-bex/walletHelpers.ts

@@ -60,7 +60,7 @@ export const getProviderNameFromChain = (chain: Chain): string => {
     case Chain.Litecoin:
       return "litecoin";
     default:
-      throw new Error("Unsupported chain");
+      throw new SwapKitError("wallet_keepkey_chain_not_supported", { chain });
   }
 };
 

package/src/keplr/index.ts

@@ -2,6 +2,7 @@ import {
   Chain,
   ChainId,
   ChainToChainId,
+  SwapKitError,
   WalletOption,
   createWallet,
   filterSupportedChains,
@@ -28,19 +29,19 @@ export const keplrWallet = createWallet({
 
           if (!keplrSupportedChainIds.includes(chainId)) {
             const chainConfig = chainRegistry.get(chainId);
-            if (!chainConfig) throw new Error(`Unsupported chain ${chain}`);
+            if (!chainConfig) throw new SwapKitError("wallet_keplr_chain_not_supported", { chain });
 
             await keplrClient.experimentalSuggestChain(chainConfig);
           }
 
           keplrClient?.enable(chainId);
           const signer = keplrClient?.getOfflineSignerOnlyAmino(chainId);
-          if (!signer) throw new Error("Could not load signer");
+          if (!signer) throw new SwapKitError("wallet_keplr_signer_not_found");
 
           const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
 
           const accounts = await signer.getAccounts();
-          if (!accounts?.[0]?.address) throw new Error("No accounts found");
+          if (!accounts?.[0]?.address) throw new SwapKitError("wallet_keplr_no_accounts");
 
           const [{ address }] = accounts;
           const toolbox = getCosmosToolbox(chain, { signer });

package/src/keystore/index.ts

@@ -23,6 +23,7 @@ export const keystoreWallet = createWallet({
     Chain.Chainflip,
     Chain.Ripple,
     Chain.Solana,
+    Chain.Tron,
   ],
   connect: ({ addChain, supportedChains, walletType }) =>
     async function connectKeystore(

package/src/ledger/clients/cosmos.ts

@@ -1,6 +1,7 @@
 import {
   type DerivationPathArray,
   NetworkDerivationPath,
+  SwapKitError,
   derivationPathToString,
 } from "@swapkit/helpers";
 import { CosmosLedgerInterface } from "../interfaces/CosmosLedgerInterface";
@@ -41,7 +42,7 @@ export class CosmosLedger extends CosmosLedgerInterface {
       rawTx,
     );
 
-    if (!this.pubKey) throw new Error("Public Key not found");
+    if (!this.pubKey) throw new SwapKitError("wallet_ledger_pubkey_not_found");
 
     this.validateResponse(return_code, error_message);
 
@@ -61,7 +62,7 @@ export class CosmosLedger extends CosmosLedgerInterface {
     const accountIndex = accounts.findIndex((account) => account.address === signerAddress);
 
     if (accountIndex === -1) {
-      throw new Error(`Address ${signerAddress} not found in wallet`);
+      throw new SwapKitError("wallet_ledger_address_not_found", { address: signerAddress });
     }
 
     const { encodeSecp256k1Signature, serializeSignDoc } = (await import("@cosmjs/amino")).default;

package/src/ledger/clients/evm.ts

@@ -3,6 +3,7 @@ import {
   ChainId,
   type DerivationPathArray,
   NetworkDerivationPath,
+  SwapKitError,
   derivationPathToString,
 } from "@swapkit/helpers";
 import { AbstractSigner, type Provider, type TransactionRequest } from "ethers";
@@ -58,7 +59,7 @@ class EVMLedgerInterface extends AbstractSigner {
 
   getAddress = async () => {
     const response = await this.getAddressAndPubKey();
-    if (!response) throw new Error("Could not get Address");
+    if (!response) throw new SwapKitError("wallet_ledger_failed_to_get_address");
     return response.address;
   };
 
@@ -78,7 +79,7 @@ class EVMLedgerInterface extends AbstractSigner {
 
     const sig = await this.ledgerApp?.signPersonalMessage(this.derivationPath, messageHex);
 
-    if (!sig) throw new Error("Signing failed");
+    if (!sig) throw new SwapKitError("wallet_ledger_signing_error");
 
     sig.r = `0x${sig.r}`;
     sig.s = `0x${sig.s}`;
@@ -86,7 +87,7 @@ class EVMLedgerInterface extends AbstractSigner {
   };
 
   sendTransaction = async (tx: TransactionRequest): Promise<any> => {
-    if (!this.provider) throw new Error("No provider set");
+    if (!this.provider) throw new SwapKitError("wallet_ledger_no_provider");
 
     const signedTxHex = await this.signTransaction(tx);
 
@@ -94,7 +95,7 @@ class EVMLedgerInterface extends AbstractSigner {
   };
 
   signTypedData(): Promise<string> {
-    throw new Error("Method not implemented.");
+    throw new SwapKitError("wallet_ledger_method_not_supported", { method: "signTypedData" });
   }
 
   signTransaction = async (tx: TransactionRequest) => {
@@ -141,7 +142,7 @@ class EVMLedgerInterface extends AbstractSigner {
       resolution,
     );
 
-    if (!signature) throw new Error("Could not sign transaction");
+    if (!signature) throw new SwapKitError("wallet_ledger_signing_error");
 
     const { r, s, v } = signature;
 

package/src/ledger/clients/thorchain/helpers.ts

@@ -1,3 +1,4 @@
+import { SwapKitError } from "@swapkit/helpers";
 import {
   CLA,
   ERROR_CODE,
@@ -10,10 +11,10 @@ import {
 
 export function serializePathv1(path: number[]) {
   if (path == null || path.length < 3) {
-    throw new Error("Invalid path.");
+    throw new SwapKitError("wallet_ledger_invalid_params", { reason: "Path too short" });
   }
   if (path.length > 10) {
-    throw new Error("Invalid path. Length should be <= 10");
+    throw new SwapKitError("wallet_ledger_invalid_params", { reason: "Path too long" });
   }
   const buf = Buffer.alloc(1 + 4 * path.length);
   buf.writeUInt8(path.length, 0);
@@ -61,7 +62,9 @@ export async function signSendChunkv1(
 
 function compressPublicKey(publicKey: Buffer) {
   if (publicKey.length !== 65) {
-    throw new Error("decompressed public key length should be 65 bytes");
+    throw new SwapKitError("wallet_ledger_invalid_params", {
+      reason: "decompressed public key length should be 65 bytes",
+    });
   }
   const y = publicKey.slice(33, 65);
 
@@ -90,7 +93,9 @@ export async function publicKeyv1(app: any, data: Buffer) {
 
 export function serializePathv2(path: number[]) {
   if (!path || path.length !== 5) {
-    throw new Error("Invalid path.");
+    throw new SwapKitError("wallet_ledger_invalid_params", {
+      reason: "Path must be exactly 5 elements",
+    });
   }
 
   const buf = Buffer.alloc(20);

package/src/ledger/clients/thorchain/index.ts

@@ -1,5 +1,5 @@
 import { base64 } from "@scure/base";
-import { type DerivationPathArray, NetworkDerivationPath } from "@swapkit/helpers";
+import { type DerivationPathArray, NetworkDerivationPath, SwapKitError } from "@swapkit/helpers";
 
 import { CosmosLedgerInterface } from "../../interfaces/CosmosLedgerInterface";
 import type { GetAddressAndPubKeyResponse } from "../../types";
@@ -64,7 +64,7 @@ export class THORChainLedger extends CosmosLedgerInterface {
       rawTx,
     );
 
-    if (!this.pubKey) throw new Error("Public Key not found");
+    if (!this.pubKey) throw new SwapKitError("wallet_ledger_pubkey_not_found");
 
     this.validateResponse(return_code, error_message);
 
@@ -85,7 +85,7 @@ export class THORChainLedger extends CosmosLedgerInterface {
       message,
     );
 
-    if (!this.pubKey) throw new Error("Public Key not found");
+    if (!this.pubKey) throw new SwapKitError("wallet_ledger_pubkey_not_found");
 
     this.validateResponse(return_code, error_message);
 

package/src/ledger/clients/thorchain/lib.ts

@@ -1,4 +1,5 @@
 import type Transport from "@ledgerhq/hw-transport";
+import { SwapKitError } from "@swapkit/helpers";
 /** ******************************************************************************
  *  (c) 2019 ZondaX GmbH
  *  (c) 2016-2017 Ledger
@@ -42,7 +43,7 @@ export class THORChainApp {
 
   constructor(transport: any) {
     if (!transport) {
-      throw new Error("Transport has not been defined");
+      throw new SwapKitError("wallet_ledger_transport_not_defined");
     }
 
     this.transport = transport;
@@ -50,7 +51,7 @@ export class THORChainApp {
 
   static serializeHRP(hrp: string) {
     if (hrp == null || hrp.length < 3 || hrp.length > 83) {
-      throw new Error("Invalid HRP");
+      throw new SwapKitError("wallet_ledger_invalid_params", { reason: "Invalid HRP" });
     }
     const buf = Buffer.alloc(1 + hrp.length);
     buf.writeUInt8(hrp.length, 0);