@swapkit/wallet-hardware 4.8.1 → 4.8.3

package/src/ledger/index.ts

@@ -0,0 +1,546 @@
+import {
+  type AssetValue,
+  Chain,
+  type DerivationPathArray,
+  derivationPathToString,
+  FeeOption,
+  filterSupportedChains,
+  type GenericTransferParams,
+  getRPCUrl,
+  NetworkDerivationPath,
+  SwapKitError,
+  THORConfig,
+  type UTXOChain,
+  WalletOption,
+} from "@swapkit/helpers";
+import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
+import {
+  addInputsAndOutputs,
+  assertDerivationIndex,
+  compileMemo,
+  createHDWalletHelpers,
+  getUTXOAccountIndexFromPath,
+  getUTXOAccountPath,
+  getUTXOAddressPath,
+  getUtxoApi,
+  type UTXOBuildTxParams,
+  type UTXOForMultiAddressTransfer,
+} from "@swapkit/toolboxes/utxo";
+import type { Transaction } from "@swapkit/utxo-signer";
+import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
+import { getLedgerAddress, getLedgerClient } from "./helpers";
+
+export const ledgerWallet = createWallet({
+  connect: ({ addChain, supportedChains, walletType }) =>
+    async function connectLedger(chains: Chain[], derivationPath?: DerivationPathArray) {
+      const [chain] = filterSupportedChains({ chains, supportedChains, walletType });
+
+      if (!chain) return false;
+
+      const resolvedPath = derivationPath ?? (NetworkDerivationPath[chain] as DerivationPathArray | undefined);
+      const walletMethods = await getWalletMethods({ chain, derivationPath: resolvedPath });
+
+      addChain({ ...walletMethods, chain, walletType: WalletOption.LEDGER });
+
+      return true;
+    },
+  directSigningSupport: {
+    [Chain.Arbitrum]: true,
+    [Chain.Aurora]: true,
+    [Chain.Avalanche]: true,
+    [Chain.Base]: true,
+    [Chain.Berachain]: true,
+    [Chain.BinanceSmartChain]: true,
+    [Chain.Ethereum]: true,
+    [Chain.Gnosis]: true,
+    [Chain.Monad]: true,
+    [Chain.Bitcoin]: true,
+    [Chain.BitcoinCash]: true,
+    [Chain.Cosmos]: true,
+    [Chain.Dash]: true,
+    [Chain.Dogecoin]: true,
+    [Chain.Litecoin]: true,
+    [Chain.Near]: true,
+    [Chain.Optimism]: true,
+    [Chain.Polygon]: true,
+    [Chain.Ripple]: true,
+    [Chain.Sui]: true,
+    [Chain.Tron]: true,
+    [Chain.XLayer]: true,
+    // ZEC: still on bespoke signPCZT path
+    // THORChain: needs signAmino added to THORChainLedger (V3 plan PR)
+  },
+  name: "connectLedger",
+  supportedChains: [
+    Chain.Arbitrum,
+    Chain.Aurora,
+    Chain.Avalanche,
+    Chain.Base,
+    Chain.Berachain,
+    Chain.BinanceSmartChain,
+    Chain.Bitcoin,
+    Chain.BitcoinCash,
+    Chain.Cosmos,
+    Chain.Dash,
+    Chain.Dogecoin,
+    Chain.Ethereum,
+    Chain.Gnosis,
+    Chain.Litecoin,
+    Chain.Monad,
+    Chain.Near,
+    Chain.Optimism,
+    Chain.Polygon,
+    Chain.Ripple,
+    Chain.Sui,
+    Chain.THORChain,
+    Chain.XLayer,
+    Chain.Tron,
+    Chain.Zcash,
+  ],
+  walletType: WalletOption.LEDGER,
+});
+
+export const LEDGER_SUPPORTED_CHAINS = getWalletSupportedChains(ledgerWallet);
+
+// reduce memo length by removing trade limit
+function reduceMemo(memo?: string, affiliateAddress = "t") {
+  if (!memo?.includes("=:")) return memo;
+
+  const removedAffiliate = memo.includes(`:${affiliateAddress}:`) ? memo.split(`:${affiliateAddress}:`)[0] : memo;
+
+  return removedAffiliate?.substring(0, removedAffiliate.lastIndexOf(":"));
+}
+
+function recursivelyOrderKeys(unordered: any) {
+  // If it's an array - recursively order any
+  // dictionary items within the array
+  if (Array.isArray(unordered)) {
+    unordered.forEach((item, index) => {
+      unordered[index] = recursivelyOrderKeys(item);
+    });
+    return unordered;
+  }
+
+  // If it's an object - let's order the keys
+  if (typeof unordered !== "object") return unordered;
+  const ordered: any = {};
+  const sortedKeys = Object.keys(unordered).sort();
+
+  for (const key of sortedKeys) {
+    ordered[key] = recursivelyOrderKeys(unordered[key]);
+  }
+
+  return ordered;
+}
+
+function stringifyKeysInOrder(data: any) {
+  return JSON.stringify(recursivelyOrderKeys(data));
+}
+
+async function getWalletMethods({ chain, derivationPath }: { chain: Chain; derivationPath?: DerivationPathArray }) {
+  switch (chain) {
+    case Chain.BitcoinCash:
+    case Chain.Bitcoin:
+    case Chain.Dash:
+    case Chain.Dogecoin:
+    case Chain.Litecoin:
+    case Chain.Zcash: {
+      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
+      const utxoChain = chain as UTXOChain;
+
+      const signer = await getLedgerClient({ chain, derivationPath });
+
+      const address = await getLedgerAddress({ chain, ledgerClient: signer });
+
+      // V3 toolbox signer:
+      //  - BTC/LTC use the modern `ledger-bitcoin` AppClient with native PSBT signing.
+      //  - BCH/DOGE/DASH use the legacy `hw-app-btc` adapter that pulls
+      //    `nonWitnessUtxo` (full prev-tx hex) out of the API PSBT.
+      //  - ZEC stays on the bespoke `signPCZT` flow for now.
+      let toolboxSigner:
+        | { getAddress: () => Promise<string>; signTransaction: (tx: Transaction) => Promise<Transaction> }
+        | undefined;
+      if (chain === Chain.Bitcoin || chain === Chain.Litecoin) {
+        const { BitcoinPsbtLedger, LitecoinPsbtLedger } = await import("./clients/utxo-psbt");
+        const psbtClient =
+          chain === Chain.Bitcoin ? BitcoinPsbtLedger(derivationPath) : LitecoinPsbtLedger(derivationPath);
+        toolboxSigner = { getAddress: psbtClient.getAddress, signTransaction: psbtClient.signTransaction };
+      } else if (chain === Chain.BitcoinCash || chain === Chain.Dogecoin || chain === Chain.Dash) {
+        const { createLegacyPsbtSigner } = await import("./clients/utxo-legacy-adapter");
+        toolboxSigner = createLegacyPsbtSigner({ address, chain: utxoChain, legacyClient: signer });
+      }
+
+      const toolbox = toolboxSigner
+        ? await getUtxoToolbox(utxoChain, { signer: toolboxSigner })
+        : getUtxoToolbox(utxoChain);
+
+      const transfer = async (params: UTXOBuildTxParams) => {
+        const feeRate = params.feeRate || (await toolbox.getFeeRates())[FeeOption.Average];
+        const memo = [Chain.Bitcoin].includes(chain as typeof Chain.Bitcoin) ? params.memo : reduceMemo(params.memo);
+
+        const { tx, inputs } = await toolbox.createTransaction({
+          ...params,
+          feeRate,
+          fetchTxHex: true,
+          memo,
+          sender: address,
+        });
+
+        // Cast tx to Transaction - signTransaction handles both Transaction and ZcashTransaction
+        // via tx.unsignedTx which exists on both types
+        const txHex = await signer.signTransaction(tx as Transaction, inputs);
+        const txHash = await toolbox.broadcastTx(txHex);
+
+        return txHash;
+      };
+
+      async function getExtendedPublicKeyInfo({ accountIndex }: { accountIndex?: number } = {}) {
+        if (!signer.getExtendedPublicKey) return undefined;
+
+        const accountPath = getUTXOAccountPath({ accountIndex, chain: utxoChain, derivationPath });
+        const path = derivationPathToString(accountPath);
+        const ledgerPath = chain === Chain.Bitcoin || chain === Chain.Litecoin ? path : path.replace(/^m\//, "");
+        const xpub = await signer.getExtendedPublicKey(ledgerPath);
+
+        return { accountIndex: getUTXOAccountIndexFromPath(accountPath), path, xpub };
+      }
+
+      function getExtendedPublicKey() {
+        return getExtendedPublicKeyInfo();
+      }
+
+      async function deriveAddressAtIndex({
+        accountIndex,
+        index,
+        change = false,
+      }: {
+        accountIndex?: number;
+        index: number;
+        change?: boolean;
+      }) {
+        try {
+          const fullPath = getUTXOAddressPath({ accountIndex, chain: utxoChain, change, derivationPath, index });
+
+          const indexedSigner = await getLedgerClient({ chain: utxoChain, derivationPath: fullPath });
+          const derivedAddress = await getLedgerAddress({ chain: utxoChain, ledgerClient: indexedSigner });
+
+          return {
+            accountIndex: getUTXOAccountIndexFromPath(fullPath),
+            address: derivedAddress,
+            change,
+            index,
+            path: derivationPathToString(fullPath),
+            pubkey: "",
+          };
+        } catch {
+          return undefined;
+        }
+      }
+
+      async function deriveAddresses({
+        accountIndex,
+        count,
+        startIndex = 0,
+        change = false,
+      }: {
+        accountIndex?: number;
+        count: number;
+        startIndex?: number;
+        change?: boolean;
+      }) {
+        assertDerivationIndex("count", count);
+        assertDerivationIndex("startIndex", startIndex);
+
+        const addresses = await Promise.all(
+          Array.from({ length: count }, (_, i) =>
+            deriveAddressAtIndex({ accountIndex, change, index: startIndex + i }),
+          ),
+        );
+
+        return addresses.filter((address) => !!address);
+      }
+
+      const hdHelpers = createHDWalletHelpers({
+        chain: utxoChain,
+        deriveAddress: deriveAddressAtIndex,
+        getBalance: toolbox.getBalance,
+        getUtxos: (addr: string) => getUtxoApi(utxoChain).getUtxos({ address: addr, fetchTxHex: true }),
+      });
+
+      async function transferFromMultipleAddresses({
+        utxos,
+        recipient,
+        assetValue,
+        memo,
+        feeRate,
+        feeOptionKey,
+        changeAddress,
+      }: {
+        utxos: UTXOForMultiAddressTransfer[];
+        recipient: string;
+        assetValue: AssetValue;
+        memo?: string;
+        feeRate?: number;
+        feeOptionKey?: FeeOption;
+        changeAddress?: string;
+      }) {
+        if (!utxos.length) {
+          throw new SwapKitError("wallet_ledger_invalid_params", {
+            message: "No UTXOs provided for multi-address transfer",
+          });
+        }
+
+        const txFeeRate = feeRate || (await toolbox.getFeeRates())[feeOptionKey || FeeOption.Fast];
+        const memoScript = memo ? compileMemo(memo) : null;
+
+        const targetOutputs: Array<{ address: string; value: number } | { script: Uint8Array; value: number }> = [
+          { address: recipient, value: assetValue.getBaseValue("number") },
+        ];
+        if (memoScript) {
+          targetOutputs.push({ script: memoScript, value: 0 });
+        }
+
+        const basicUtxos = utxos.map(({ hash, index, value, txHex, witnessUtxo }) => ({
+          hash,
+          index,
+          txHex,
+          value,
+          witnessUtxo,
+        }));
+
+        const { inputs: selectedInputs, outputs } = toolbox.accumulative({
+          chain: utxoChain,
+          feeRate: txFeeRate,
+          inputs: basicUtxos,
+          outputs: targetOutputs,
+        });
+
+        if (!(selectedInputs && outputs)) {
+          throw new SwapKitError("wallet_ledger_connection_error", {
+            message: "Insufficient balance for multi-address transfer",
+          });
+        }
+
+        const { Transaction } = await import("@swapkit/utxo-signer");
+        const tx = new Transaction({ allowLegacyWitnessUtxo: true, version: 1 });
+        const senderAddress = changeAddress || utxos[0]?.address || recipient;
+
+        addInputsAndOutputs({
+          chain: utxoChain,
+          compiledMemo: memoScript,
+          inputs: selectedInputs,
+          outputs,
+          sender: senderAddress,
+          tx,
+        });
+
+        const basePath = getUTXOAccountPath({ chain: utxoChain, derivationPath });
+        const inputDerivationPaths = selectedInputs.map((input: { hash: string; index: number }) => {
+          const utxoInfo = utxos.find((u) => u.hash === input.hash && u.index === input.index);
+          const derivationIndex = utxoInfo?.derivationIndex ?? 0;
+          const isChange = utxoInfo?.isChange ?? false;
+          const fullPath = [...basePath, Number(isChange), derivationIndex] as unknown as DerivationPathArray;
+          return derivationPathToString(fullPath);
+        });
+
+        if (!signer.signTransactionWithMultiplePaths) {
+          throw new SwapKitError("wallet_ledger_method_not_supported", { method: "signTransactionWithMultiplePaths" });
+        }
+
+        const txHex = await signer.signTransactionWithMultiplePaths(tx, selectedInputs, inputDerivationPaths);
+        return toolbox.broadcastTx(txHex);
+      }
+
+      return {
+        ...toolbox,
+        ...hdHelpers,
+        address,
+        deriveAddressAtIndex,
+        deriveAddresses,
+        getExtendedPublicKey,
+        getExtendedPublicKeyInfo,
+        transfer,
+        transferFromMultipleAddresses,
+      };
+    }
+
+    case Chain.Ethereum:
+    case Chain.Avalanche:
+    case Chain.Arbitrum:
+    case Chain.Berachain:
+    case Chain.Optimism:
+    case Chain.Polygon:
+    case Chain.BinanceSmartChain:
+    case Chain.Base:
+    case Chain.Aurora:
+    case Chain.Gnosis:
+    case Chain.Monad:
+    case Chain.XLayer: {
+      const { getEvmToolboxAsync } = await import("@swapkit/toolboxes/evm");
+      const signer = await getLedgerClient({ chain, derivationPath });
+      const address = await getLedgerAddress({ chain, ledgerClient: signer });
+      const toolbox = await getEvmToolboxAsync(chain, { signer });
+
+      return { ...toolbox, address };
+    }
+
+    case Chain.Cosmos: {
+      const { createSigningStargateClient, getMsgSendDenom, getCosmosToolbox } = await import(
+        "@swapkit/toolboxes/cosmos"
+      );
+      const signer = await getLedgerClient({ chain, derivationPath });
+      const address = await getLedgerAddress({ chain, ledgerClient: signer });
+      const toolbox = await getCosmosToolbox(Chain.Cosmos, { signer });
+
+      const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
+        if (!assetValue) throw new SwapKitError("wallet_ledger_invalid_asset");
+
+        const sendCoinsMessage = {
+          amount: [
+            {
+              amount: assetValue.getBaseValue("string"),
+              denom: getMsgSendDenom(`u${assetValue.symbol}`).toLowerCase(),
+            },
+          ],
+          fromAddress: address,
+          toAddress: recipient,
+        };
+
+        const rpcUrl = await getRPCUrl(chain);
+        const signingClient = await createSigningStargateClient(rpcUrl, signer, "0.007uatom");
+
+        const { transactionHash } = await signingClient.signAndBroadcast(
+          address,
+          [{ typeUrl: "/cosmos.bank.v1beta1.MsgSend", value: sendCoinsMessage }],
+          2,
+          memo,
+        );
+
+        return transactionHash;
+      };
+
+      return { ...toolbox, address, transfer };
+    }
+
+    case Chain.THORChain: {
+      const { SignMode } = await import("cosmjs-types/cosmos/tx/signing/v1beta1/signing.js");
+      const { TxRaw } = await import("cosmjs-types/cosmos/tx/v1beta1/tx.js");
+      const importedSigning = await import("@cosmjs/proto-signing");
+      const encodePubkey = importedSigning.encodePubkey ?? importedSigning.default?.encodePubkey;
+      const makeAuthInfoBytes = importedSigning.makeAuthInfoBytes ?? importedSigning.default?.makeAuthInfoBytes;
+      const {
+        createStargateClient,
+        buildEncodedTxBody,
+        getCosmosToolbox,
+        buildAminoMsg,
+        getDefaultChainFee,
+        fromBase64,
+        parseAminoMessageForDirectSigning,
+      } = await import("@swapkit/toolboxes/cosmos");
+      const toolbox = getCosmosToolbox(chain);
+      const signer = await getLedgerClient({ chain, derivationPath });
+      const address = await getLedgerAddress({ chain, ledgerClient: signer });
+
+      const fee = getDefaultChainFee(chain);
+      const { pubkey: value, signTransaction, sign: signMessage } = signer;
+
+      // ANCHOR (@Chillios): Same parts in methods + can extract StargateClient init to toolbox
+      const thorchainTransfer = async ({
+        memo = "",
+        assetValue,
+        ...rest
+      }: GenericTransferParams | ThorchainDepositParams) => {
+        const account = await toolbox.getAccount(address);
+        if (!account) throw new SwapKitError("wallet_ledger_invalid_account");
+        if (!assetValue) throw new SwapKitError("wallet_ledger_invalid_asset");
+        if (!value) throw new SwapKitError("wallet_ledger_pubkey_not_found");
+
+        const { accountNumber, sequence: sequenceNumber } = account;
+        const sequence = (sequenceNumber || 0).toString();
+
+        const orderedMessages = recursivelyOrderKeys([buildAminoMsg({ assetValue, memo, sender: address, ...rest })]);
+
+        // get tx signing msg
+        const rawSendTx = stringifyKeysInOrder({
+          account_number: accountNumber?.toString(),
+          chain_id: THORConfig.chainId,
+          fee,
+          memo,
+          msgs: orderedMessages,
+          sequence,
+        });
+
+        const signatures = await signTransaction(rawSendTx, sequence);
+        if (!signatures) throw new SwapKitError("wallet_ledger_signing_error");
+
+        const pubkey = encodePubkey({ type: "tendermint/PubKeySecp256k1", value });
+        const msgs = orderedMessages.map(parseAminoMessageForDirectSigning);
+        const bodyBytes = await buildEncodedTxBody({ chain, memo, msgs });
+
+        const authInfoBytes = makeAuthInfoBytes(
+          [{ pubkey, sequence: Number(sequence) }],
+          fee.amount,
+          Number.parseInt(fee.gas, 10),
+          undefined,
+          undefined,
+          SignMode.SIGN_MODE_LEGACY_AMINO_JSON,
+        );
+
+        const signature = signatures?.[0]?.signature ? fromBase64(signatures[0].signature) : Uint8Array.from([]);
+
+        const txRaw = TxRaw.fromPartial({ authInfoBytes, bodyBytes, signatures: [signature] });
+        const txBytes = TxRaw.encode(txRaw).finish();
+        const rpcUrl = await getRPCUrl(Chain.THORChain);
+
+        const broadcaster = await createStargateClient(rpcUrl);
+        const { transactionHash } = await broadcaster.broadcastTx(txBytes);
+
+        return transactionHash;
+      };
+
+      const transfer = (params: GenericTransferParams) => thorchainTransfer(params);
+      const deposit = (params: ThorchainDepositParams) => thorchainTransfer(params);
+
+      return { ...toolbox, address, deposit, signMessage, transfer };
+    }
+
+    case Chain.Near: {
+      const { getNearToolbox } = await import("@swapkit/toolboxes/near");
+      const signer = await getLedgerClient({ chain, derivationPath });
+      const accountId = await signer.getAddress();
+      const toolbox = getNearToolbox({ signer });
+
+      return { ...toolbox, address: accountId };
+    }
+
+    case Chain.Ripple: {
+      const { getRippleToolbox } = await import("@swapkit/toolboxes/ripple");
+      const signer = await getLedgerClient({ chain, derivationPath });
+      const address = signer.getAddress();
+      const toolbox = getRippleToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
+    case Chain.Tron: {
+      const { getTronToolbox } = await import("@swapkit/toolboxes/tron");
+      const signer = await getLedgerClient({ chain, derivationPath });
+      const address = await getLedgerAddress({ chain, ledgerClient: signer });
+      const toolbox = getTronToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
+    case Chain.Sui: {
+      const { getSuiToolbox } = await import("@swapkit/toolboxes/sui");
+      const signer = await getLedgerClient({ chain, derivationPath });
+      const address = await getLedgerAddress({ chain, ledgerClient: signer });
+      const toolbox = getSuiToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
+    default:
+      throw new SwapKitError("wallet_ledger_chain_not_supported", { chain });
+  }
+}

package/src/ledger/interfaces/CosmosLedgerInterface.ts

@@ -0,0 +1,54 @@
+import { type DerivationPathArray, LedgerErrorCode, NetworkDerivationPath, SwapKitError } from "@swapkit/helpers";
+
+import { THORChainApp } from "../clients/thorchain/lib";
+import { getLedgerTransport } from "../helpers/getLedgerTransport";
+
+export abstract class CosmosLedgerInterface {
+  ledgerTimeout = 50000;
+  derivationPath: DerivationPathArray | string = NetworkDerivationPath.GAIA;
+  transport: any;
+  ledgerApp: any;
+  chain: "thor" | "cosmos" = "thor";
+
+  checkOrCreateTransportAndLedger = async (forceReconnect = false) => {
+    if (!forceReconnect && this.transport && this.ledgerApp) return;
+
+    try {
+      this.transport = forceReconnect || !this.transport ? await getLedgerTransport() : this.transport;
+
+      switch (this.chain) {
+        case "thor": {
+          this.ledgerApp = forceReconnect || !this.ledgerApp ? new THORChainApp(this.transport) : this.ledgerApp;
+
+          break;
+        }
+
+        case "cosmos": {
+          const CosmosApp = (await import("@ledgerhq/hw-app-cosmos")).default;
+          this.ledgerApp = forceReconnect || !this.ledgerApp ? new CosmosApp(this.transport) : this.ledgerApp;
+        }
+      }
+
+      return this.ledgerApp;
+    } catch (error: unknown) {
+      throw new SwapKitError("wallet_ledger_connection_error", error);
+    }
+  };
+
+  validateResponse = (errorCode: LedgerErrorCode, message?: string) => {
+    switch (errorCode) {
+      case LedgerErrorCode.NoError:
+        return;
+
+      case LedgerErrorCode.LockedDevice:
+        throw new SwapKitError("wallet_ledger_device_locked", { message: `Ledger is locked: ${message}` });
+
+      case LedgerErrorCode.TC_NotFound:
+        throw new SwapKitError("wallet_ledger_device_not_found");
+
+      default: {
+        break;
+      }
+    }
+  };
+}

package/src/ledger/types.ts

@@ -0,0 +1,42 @@
+import type { CosmosLedger } from "./clients/cosmos";
+import type {
+  ArbitrumLedger,
+  AuroraLedger,
+  AvalancheLedger,
+  BaseLedger,
+  BinanceSmartChainLedger,
+  EthereumLedger,
+  GnosisLedger,
+  OptimismLedger,
+  PolygonLedger,
+} from "./clients/evm";
+import type { SuiLedger } from "./clients/sui";
+import type { THORChainLedger } from "./clients/thorchain";
+import type { TronLedger } from "./clients/tron";
+import type { BitcoinCashLedger, BitcoinLedger, DogecoinLedger, LitecoinLedger } from "./clients/utxo";
+
+export type UTXOLedgerClients =
+  | ReturnType<typeof BitcoinLedger>
+  | ReturnType<typeof BitcoinCashLedger>
+  | ReturnType<typeof DogecoinLedger>
+  | ReturnType<typeof LitecoinLedger>;
+export type CosmosLedgerClients = CosmosLedger | THORChainLedger;
+export type EVMLedgerClients =
+  | ReturnType<typeof ArbitrumLedger>
+  | ReturnType<typeof AuroraLedger>
+  | ReturnType<typeof AvalancheLedger>
+  | ReturnType<typeof BaseLedger>
+  | ReturnType<typeof BinanceSmartChainLedger>
+  | ReturnType<typeof GnosisLedger>
+  | ReturnType<typeof EthereumLedger>
+  | ReturnType<typeof OptimismLedger>
+  | ReturnType<typeof PolygonLedger>;
+export type TronLedgerClient = ReturnType<typeof TronLedger>;
+export type SuiLedgerClient = ReturnType<typeof SuiLedger>;
+
+export type GetAddressAndPubKeyResponse = {
+  bech32_address: string;
+  compressed_pk: any;
+  error_message: string;
+  return_code: number;
+};