@rango-dev/provider-ledger 0.0.0-experimental-936229e8-20251208

package/src/signers/solana.ts

@@ -0,0 +1,94 @@
+import type { SolanaWeb3Signer } from '@rango-dev/signer-solana';
+import type { Transaction, VersionedTransaction } from '@solana/web3.js';
+import type { GenericSigner, SolanaTransaction } from 'rango-types';
+
+import { generalSolanaTransactionExecutor } from '@rango-dev/signer-solana';
+import { dynamicImportWithRefinedError } from '@rango-dev/wallets-shared';
+import { PublicKey } from '@solana/web3.js';
+import { SignerError, SignerErrorCode } from 'rango-types';
+
+import { getDerivationPath } from '../state.js';
+import {
+  getLedgerError,
+  transportConnect,
+  transportDisconnect,
+} from '../utils.js';
+
+export function isVersionedTransaction(
+  transaction: Transaction | VersionedTransaction
+): transaction is VersionedTransaction {
+  return 'version' in transaction;
+}
+
+export class SolanaSigner implements GenericSigner<SolanaTransaction> {
+  async signMessage(msg: string): Promise<string> {
+    try {
+      const transport = await transportConnect();
+      const LedgerAppSolana = (
+        await dynamicImportWithRefinedError(
+          async () => await import('@ledgerhq/hw-app-solana')
+        )
+      ).default;
+      const solana = new LedgerAppSolana(transport);
+
+      const result = await solana.signOffchainMessage(
+        getDerivationPath(),
+        Buffer.from(msg)
+      );
+      return result.signature.toString();
+    } catch (error) {
+      throw new SignerError(SignerErrorCode.SIGN_TX_ERROR, undefined, error);
+    }
+  }
+
+  async signAndSendTx(tx: SolanaTransaction): Promise<{ hash: string }> {
+    try {
+      const DefaultSolanaSigner: SolanaWeb3Signer = async (
+        solanaWeb3Transaction: Transaction | VersionedTransaction
+      ) => {
+        const transport = await transportConnect();
+        const LedgerAppSolana = (
+          await dynamicImportWithRefinedError(
+            async () => await import('@ledgerhq/hw-app-solana')
+          )
+        ).default;
+        const solana = new LedgerAppSolana(transport);
+
+        let signResult;
+        if (isVersionedTransaction(solanaWeb3Transaction)) {
+          signResult = await solana.signTransaction(
+            getDerivationPath(),
+            solanaWeb3Transaction.message.serialize() as Buffer
+          );
+        } else {
+          signResult = await solana.signTransaction(
+            getDerivationPath(),
+            solanaWeb3Transaction.serialize()
+          );
+        }
+
+        const addressResult = await solana.getAddress(getDerivationPath());
+
+        const publicKey = new PublicKey(addressResult.address);
+
+        solanaWeb3Transaction.addSignature(
+          publicKey,
+          Buffer.from(signResult.signature)
+        );
+
+        const serializedTx = solanaWeb3Transaction.serialize();
+
+        return serializedTx;
+      };
+      const hash = await generalSolanaTransactionExecutor(
+        tx,
+        DefaultSolanaSigner
+      );
+      return { hash };
+    } catch (error) {
+      throw getLedgerError(error);
+    } finally {
+      await transportDisconnect();
+    }
+  }
+}

package/src/state.ts

@@ -0,0 +1,10 @@
+// We keep derivationPath here because we need to maintain it for signing transactions after it is set in connect method
+let derivationPath = '';
+
+export function setDerivationPath(path: string) {
+  derivationPath = path;
+}
+
+export function getDerivationPath() {
+  return derivationPath;
+}

package/src/utils.ts

@@ -0,0 +1,140 @@
+import type Transport from '@ledgerhq/hw-transport';
+
+import { getAltStatusMessage } from '@ledgerhq/errors';
+import { LegacyNetworks } from '@rango-dev/wallets-core/legacy';
+import { CAIP_SOLANA_CHAIN_ID } from '@rango-dev/wallets-core/namespaces/solana';
+import {
+  dynamicImportWithRefinedError,
+  ETHEREUM_CHAIN_ID,
+  type ProviderConnectResult,
+} from '@rango-dev/wallets-shared';
+import bs58 from 'bs58';
+
+import { HEXADECIMAL_BASE } from './constants.js';
+import { getDerivationPath } from './state.js';
+
+export type Provider = Map<string, unknown>;
+
+export function ledger(): Provider | null {
+  /*
+   * Instances have a required property which is `chainId` and is using in swap execution.
+   * Here we are setting it as Ethereum always since we are supporting only eth for now.
+   */
+  const instances = new Map();
+
+  instances.set(LegacyNetworks.ETHEREUM, { chainId: ETHEREUM_CHAIN_ID });
+  instances.set(LegacyNetworks.SOLANA, { chainId: LegacyNetworks.SOLANA });
+
+  return instances;
+}
+
+const ledgerFrequentErrorMessages: { [statusCode: number]: string } = {
+  0x5515: 'The device is locked',
+  0x650f: 'Related application is not ready on your device',
+  0x6985: 'Action denied by user',
+};
+
+function getLedgerErrorMessage(statusCode: number): string {
+  if (ledgerFrequentErrorMessages[statusCode]) {
+    return ledgerFrequentErrorMessages[statusCode];
+  } else if (getAltStatusMessage(statusCode)) {
+    return getAltStatusMessage(statusCode) as string;
+  }
+
+  return `Ledger device unknown error 0x${statusCode.toString(
+    HEXADECIMAL_BASE
+  )}`; // Hexadecimal numbers are more commonly recognized and utilized for representing ledger error codes
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getLedgerError(error: any) {
+  if (error?.statusCode) {
+    return new Error(getLedgerErrorMessage(error.statusCode));
+  }
+
+  if (error?.code === 'INSUFFICIENT_FUNDS') {
+    return new Error('Insufficient funds for transaction');
+  }
+  return error;
+}
+
+export function standardizeAndThrowLedgerError(_: unknown, error: unknown) {
+  throw getLedgerError(error);
+}
+
+export async function getEthereumAccounts(): Promise<ProviderConnectResult> {
+  try {
+    const transport = await transportConnect();
+    const LedgerAppEth = (
+      await dynamicImportWithRefinedError(
+        async () => await import('@ledgerhq/hw-app-eth')
+      )
+    ).default;
+    const eth = new LedgerAppEth(transport);
+    const derivationPath = getDerivationPath();
+
+    const accounts: string[] = [];
+
+    const result = await eth.getAddress(derivationPath, false, true);
+    accounts.push(result.address);
+
+    return {
+      accounts: accounts,
+      chainId: ETHEREUM_CHAIN_ID,
+      derivationPath,
+    };
+  } catch (error: unknown) {
+    throw getLedgerError(error);
+  } finally {
+    await transportDisconnect();
+  }
+}
+
+export async function getSolanaAccounts(): Promise<ProviderConnectResult> {
+  try {
+    const transport = await transportConnect();
+    const LedgerAppSolana = (
+      await dynamicImportWithRefinedError(
+        async () => await import('@ledgerhq/hw-app-solana')
+      )
+    ).default;
+    const solana = new LedgerAppSolana(transport);
+    const derivationPath = getDerivationPath();
+
+    const accounts: string[] = [];
+
+    const result = await solana.getAddress(derivationPath);
+    accounts.push(bs58.encode(result.address));
+
+    return {
+      accounts: accounts,
+      chainId: CAIP_SOLANA_CHAIN_ID,
+      derivationPath,
+    };
+  } catch (error: unknown) {
+    throw getLedgerError(error);
+  } finally {
+    await transportDisconnect();
+  }
+}
+
+let transportConnection: Transport | null = null;
+
+export async function transportConnect() {
+  const TransportWebHID = (
+    await dynamicImportWithRefinedError(
+      async () => await import('@ledgerhq/hw-transport-webhid')
+    )
+  ).default;
+
+  transportConnection = await TransportWebHID.create();
+
+  return transportConnection;
+}
+
+export async function transportDisconnect() {
+  if (transportConnection) {
+    await transportConnection.close();
+    transportConnection = null;
+  }
+}