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

package/dist/provider.d.ts

@@ -0,0 +1,2 @@
+declare const buildProvider: () => import("@rango-dev/wallets-core").Provider;
+export { buildProvider };

package/dist/signer.d.ts

@@ -0,0 +1,2 @@
+import type { SignerFactory } from 'rango-types';
+export default function getSigners(): Promise<SignerFactory>;

package/dist/signers/ethereum.d.ts

@@ -0,0 +1,8 @@
+import type { GenericSigner } from 'rango-types';
+import type { EvmTransaction } from 'rango-types/mainApi';
+export declare class EthereumSigner implements GenericSigner<EvmTransaction> {
+    signMessage(msg: string): Promise<string>;
+    signAndSendTx(tx: EvmTransaction, fromAddress: string, chainId: string | null): Promise<{
+        hash: string;
+    }>;
+}

package/dist/signers/solana.d.ts

@@ -0,0 +1,9 @@
+import type { Transaction, VersionedTransaction } from '@solana/web3.js';
+import type { GenericSigner, SolanaTransaction } from 'rango-types';
+export declare function isVersionedTransaction(transaction: Transaction | VersionedTransaction): transaction is VersionedTransaction;
+export declare class SolanaSigner implements GenericSigner<SolanaTransaction> {
+    signMessage(msg: string): Promise<string>;
+    signAndSendTx(tx: SolanaTransaction): Promise<{
+        hash: string;
+    }>;
+}

package/dist/state.d.ts

@@ -0,0 +1,2 @@
+export declare function setDerivationPath(path: string): void;
+export declare function getDerivationPath(): string;

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+import type Transport from '@ledgerhq/hw-transport';
+import { type ProviderConnectResult } from '@rango-dev/wallets-shared';
+export type Provider = Map<string, unknown>;
+export declare function ledger(): Provider | null;
+export declare function getLedgerError(error: any): any;
+export declare function standardizeAndThrowLedgerError(_: unknown, error: unknown): void;
+export declare function getEthereumAccounts(): Promise<ProviderConnectResult>;
+export declare function getSolanaAccounts(): Promise<ProviderConnectResult>;
+export declare function transportConnect(): Promise<Transport>;
+export declare function transportDisconnect(): Promise<void>;

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@rango-dev/provider-ledger",
+  "version": "0.0.0-experimental-936229e8-20251208",
+  "license": "MIT",
+  "type": "module",
+  "source": "./src/mod.ts",
+  "main": "./dist/mod.js",
+  "exports": {
+    ".": "./dist/mod.js"
+  },
+  "typings": "dist/mod.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "node ../../scripts/build/command.mjs --path wallets/provider-ledger --splitting --external-all-except @ledgerhq/errors,@ledgerhq/hw-app-eth,@ledgerhq/hw-app-solana,@ledgerhq/hw-transport-webhid,@ledgerhq/types-cryptoassets,@ledgerhq/types-devices  --inputs src/mod.ts",
+    "ts-check": "tsc --declaration --emitDeclarationOnly -p ./tsconfig.json",
+    "clean": "rimraf dist",
+    "format": "prettier --write '{.,src}/**/*.{ts,tsx}'",
+    "lint": "eslint \"**/*.{ts,tsx}\""
+  },
+  "dependencies": {
+    "@ledgerhq/errors": "^6.16.4",
+    "@ledgerhq/hw-app-eth": "^6.36.0",
+    "@ledgerhq/hw-app-solana": "^7.1.6",
+    "@ledgerhq/hw-transport-webhid": "^6.28.6",
+    "@ledgerhq/types-cryptoassets": "^7.11.0",
+    "@ledgerhq/types-devices": "^6.24.0",
+    "@rango-dev/signer-solana": "^0.46.1",
+    "@rango-dev/wallets-core": "^0.0.0-experimental-936229e8-20251208",
+    "@rango-dev/wallets-shared": "^0.0.0-experimental-936229e8-20251208",
+    "@solana/web3.js": "^1.91.4",
+    "@types/w3c-web-hid": "^1.0.2",
+    "bs58": "^5.0.0",
+    "ethers": "^6.13.2",
+    "rango-types": "^0.1.89"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/readme.md

@@ -0,0 +1,16 @@
+# Ledger
+
+Ledger integration for hub.  
+[Homepage](https://www.ledger.com/) | [Docs](https://developers.ledger.com/)
+
+## Implementation notes/limitations
+
+### Group
+
+#### ⚠️ EVM
+
+We only support Ethereum for now.
+
+---
+
+More wallet information can be found in [readme.md](../readme.md).

package/src/constants.ts

@@ -0,0 +1,91 @@
+import { type ProviderMetadata } from '@rango-dev/wallets-core';
+import { LegacyNetworks } from '@rango-dev/wallets-core/legacy';
+import { Networks } from '@rango-dev/wallets-shared';
+import { type BlockchainMeta } from 'rango-types';
+
+import getSigners from './signer.js';
+
+export const EVM_SUPPORTED_CHAINS = [
+  LegacyNetworks.ETHEREUM,
+  LegacyNetworks.POLYGON,
+  LegacyNetworks.BASE,
+];
+
+export const HEXADECIMAL_BASE = 16;
+export const WALLET_ID = 'ledger';
+
+export const metadata: ProviderMetadata = {
+  name: 'Ledger',
+  icon: 'https://raw.githubusercontent.com/rango-exchange/assets/main/wallets/ledger/icon.svg',
+  extensions: {
+    homepage:
+      'https://support.ledger.com/hc/en-us/articles/4404389606417-Download-and-install-Ledger-Live?docs=true',
+  },
+  properties: [
+    {
+      name: 'namespaces',
+      value: {
+        selection: 'single',
+        data: [
+          {
+            label: 'Ethereum',
+            value: 'EVM',
+            id: 'ETH',
+            getSupportedChains: (allBlockchains: BlockchainMeta[]) =>
+              allBlockchains.filter(
+                (chain) => chain.name === Networks.ETHEREUM
+              ),
+          },
+          {
+            label: 'Solana',
+            value: 'Solana',
+            id: 'SOLANA',
+            getSupportedChains: (allBlockchains: BlockchainMeta[]) =>
+              allBlockchains.filter((chain) => chain.name === Networks.SOLANA),
+          },
+        ],
+      },
+    },
+    {
+      name: 'derivationPath',
+      value: {
+        data: [
+          {
+            id: 'metamask',
+            label: `Metamask (m/44'/60'/0'/0/index)`,
+            namespace: 'EVM',
+            generateDerivationPath: (index: string) => `44'/60'/0'/0/${index}`,
+          },
+          {
+            id: 'ledgerLive',
+            label: `LedgerLive (m/44'/60'/index'/0/0)`,
+            namespace: 'EVM',
+            generateDerivationPath: (index: string) => `44'/60'/${index}'/0/0`,
+          },
+          {
+            id: 'legacy',
+            label: `Legacy (m/44'/60'/0'/index)`,
+            namespace: 'EVM',
+            generateDerivationPath: (index: string) => `44'/60'/0'/${index}`,
+          },
+          {
+            id: `(m/44'/501'/index')`,
+            label: `(m/44'/501'/index')`,
+            namespace: 'Solana',
+            generateDerivationPath: (index: string) => `44'/501'/${index}'`,
+          },
+          {
+            id: `(m/44'/501'/0'/index)`,
+            label: `(m/44'/501'/0'/index)`,
+            namespace: 'Solana',
+            generateDerivationPath: (index: string) => `44'/501'/0'/${index}`,
+          },
+        ],
+      },
+    },
+    {
+      name: 'signers',
+      value: { getSigners: async () => getSigners() },
+    },
+  ],
+};

package/src/legacy/index.ts

@@ -0,0 +1,167 @@
+import type { LegacyProviderInterface } from '@rango-dev/wallets-core/legacy';
+import type {
+  Connect,
+  Disconnect,
+  ProviderConnectResult,
+  WalletInfo,
+} from '@rango-dev/wallets-shared';
+
+import { Networks, WalletTypes } from '@rango-dev/wallets-shared';
+import { type BlockchainMeta, type SignerFactory } from 'rango-types';
+
+import signer from '../signer.js';
+import { setDerivationPath } from '../state.js';
+import {
+  getEthereumAccounts,
+  ledger as getLedgerInstance,
+  getSolanaAccounts,
+  transportDisconnect,
+} from '../utils.js';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type InstanceType = any;
+
+export const config = {
+  type: WalletTypes.LEDGER,
+};
+
+export const getInstance = getLedgerInstance;
+export const connect: Connect = async ({ namespaces }) => {
+  const results: ProviderConnectResult[] = [];
+
+  const solanaNamespace = namespaces?.find(
+    (namespaceItem) => namespaceItem.namespace === 'Solana'
+  );
+  const evmNamespace = namespaces?.find(
+    (namespaceItem) => namespaceItem.namespace === 'EVM'
+  );
+
+  if (solanaNamespace) {
+    if (solanaNamespace.derivationPath) {
+      setDerivationPath(solanaNamespace.derivationPath);
+      const accounts = await getSolanaAccounts();
+      results.push(accounts);
+    } else {
+      throw new Error('Derivation Path can not be empty.');
+    }
+  } else if (evmNamespace) {
+    if (evmNamespace.derivationPath) {
+      setDerivationPath(evmNamespace.derivationPath);
+      const accounts = await getEthereumAccounts();
+      results.push(accounts);
+    } else {
+      throw new Error('Derivation Path can not be empty.');
+    }
+  } else {
+    throw new Error(
+      `It appears that you have selected a namespace that is not yet supported by our system. Your namespaces: ${namespaces?.map(
+        (namespaceItem) => namespaceItem.namespace
+      )}`
+    );
+  }
+
+  return results;
+};
+
+export const disconnect: Disconnect = async () => {
+  void transportDisconnect();
+};
+
+export const getSigners: (provider: InstanceType) => Promise<SignerFactory> =
+  signer;
+
+export const getWalletInfo: (allBlockChains: BlockchainMeta[]) => WalletInfo = (
+  allBlockChains
+) => {
+  const supportedChains: BlockchainMeta[] = [];
+
+  const ethereumBlockchain = allBlockChains.find(
+    (chain) => chain.name === Networks.ETHEREUM
+  );
+  if (ethereumBlockchain) {
+    supportedChains.push(ethereumBlockchain);
+  }
+
+  const solanaBlockchain = allBlockChains.find(
+    (chain) => chain.name === Networks.SOLANA
+  );
+  if (solanaBlockchain) {
+    supportedChains.push(solanaBlockchain);
+  }
+
+  return {
+    name: 'Ledger',
+    img: 'https://raw.githubusercontent.com/rango-exchange/assets/main/wallets/ledger/icon.svg',
+    installLink: {
+      DEFAULT:
+        'https://support.ledger.com/hc/en-us/articles/4404389606417-Download-and-install-Ledger-Live?docs=true',
+    },
+    color: 'black',
+    supportedChains,
+    showOnMobile: false,
+    needsDerivationPath: {
+      data: [
+        {
+          id: 'metamask',
+          label: `Metamask (m/44'/60'/0'/0/index)`,
+          namespace: 'EVM',
+          generateDerivationPath: (index: string) => `44'/60'/0'/0/${index}`,
+        },
+        {
+          id: 'ledgerLive',
+          label: `LedgerLive (m/44'/60'/index'/0/0)`,
+          namespace: 'EVM',
+          generateDerivationPath: (index: string) => `44'/60'/${index}'/0/0`,
+        },
+        {
+          id: 'legacy',
+          label: `Legacy (m/44'/60'/0'/index)`,
+          namespace: 'EVM',
+          generateDerivationPath: (index: string) => `44'/60'/0'/${index}`,
+        },
+        {
+          id: `(m/44'/501'/index')`,
+          label: `(m/44'/501'/index')`,
+          namespace: 'Solana',
+          generateDerivationPath: (index: string) => `44'/501'/${index}'`,
+        },
+        {
+          id: `(m/44'/501'/0'/index)`,
+          label: `(m/44'/501'/0'/index)`,
+          namespace: 'Solana',
+          generateDerivationPath: (index: string) => `44'/501'/0'/${index}`,
+        },
+      ],
+    },
+
+    needsNamespace: {
+      selection: 'single',
+      data: [
+        {
+          label: 'EVM',
+          value: 'EVM',
+          id: 'ETH',
+          getSupportedChains: (allBlockchains: BlockchainMeta[]) =>
+            allBlockchains.filter((chain) => chain.name === Networks.ETHEREUM),
+        },
+        {
+          label: 'Solana',
+          value: 'Solana',
+          id: 'SOLANA',
+          getSupportedChains: (allBlockchains: BlockchainMeta[]) =>
+            allBlockchains.filter((chain) => chain.name === Networks.SOLANA),
+        },
+      ],
+    },
+  };
+};
+
+const buildLegacyProvider: () => LegacyProviderInterface = () => ({
+  config,
+  getInstance,
+  connect,
+  getSigners,
+  getWalletInfo,
+});
+
+export { buildLegacyProvider };

package/src/mod.ts

@@ -0,0 +1,12 @@
+import { defineVersions } from '@rango-dev/wallets-core/utils';
+
+import { buildLegacyProvider } from './legacy/index.js';
+import { buildProvider } from './provider.js';
+
+const versions = () =>
+  defineVersions()
+    .version('0.0.0', buildLegacyProvider())
+    .version('1.0.0', buildProvider())
+    .build();
+
+export { versions };

package/src/namespaces/evm.ts

@@ -0,0 +1,65 @@
+import type { EvmActions } from '@rango-dev/wallets-core/namespaces/evm';
+
+import { NamespaceBuilder } from '@rango-dev/wallets-core';
+import {
+  type CaipAccount,
+  builders as commonBuilders,
+} from '@rango-dev/wallets-core/namespaces/common';
+import {
+  builders,
+  CAIP_NAMESPACE,
+} from '@rango-dev/wallets-core/namespaces/evm';
+import { CAIP } from '@rango-dev/wallets-core/utils';
+import { ETHEREUM_CHAIN_ID } from '@rango-dev/wallets-shared';
+
+import { WALLET_ID } from '../constants.js';
+import { setDerivationPath } from '../state.js';
+import {
+  getEthereumAccounts,
+  standardizeAndThrowLedgerError,
+} from '../utils.js';
+
+const connect = builders
+  .connect()
+  .action(async function (_context, _chain, options) {
+    if (!options?.derivationPath) {
+      throw new Error('Derivation Path can not be empty.');
+    }
+
+    setDerivationPath(options.derivationPath);
+
+    const result = await getEthereumAccounts();
+
+    const formatAccounts = result.accounts.map(
+      (account) =>
+        CAIP.AccountId.format({
+          address: account,
+          chainId: {
+            namespace: CAIP_NAMESPACE,
+            reference: result.chainId,
+          },
+        }) as CaipAccount
+    );
+
+    return {
+      accounts: formatAccounts,
+      network: result.chainId,
+    };
+  })
+  .or(standardizeAndThrowLedgerError)
+  .build();
+
+const disconnect = commonBuilders.disconnect<EvmActions>().build();
+
+const getChainId = builders
+  .getChainId()
+  .action(() => ETHEREUM_CHAIN_ID)
+  .build();
+
+const evm = new NamespaceBuilder<EvmActions>('EVM', WALLET_ID)
+  .action(connect)
+  .action(disconnect)
+  .action(getChainId)
+  .build();
+
+export { evm };

package/src/namespaces/solana.ts

@@ -0,0 +1,50 @@
+import type { CaipAccount } from '@rango-dev/wallets-core/namespaces/common';
+import type { SolanaActions } from '@rango-dev/wallets-core/namespaces/solana';
+
+import { NamespaceBuilder } from '@rango-dev/wallets-core';
+import { builders as commonBuilders } from '@rango-dev/wallets-core/namespaces/common';
+import {
+  builders,
+  CAIP_NAMESPACE,
+} from '@rango-dev/wallets-core/namespaces/solana';
+import { CAIP } from '@rango-dev/wallets-core/utils';
+
+import { WALLET_ID } from '../constants.js';
+import { setDerivationPath } from '../state.js';
+import { getSolanaAccounts, standardizeAndThrowLedgerError } from '../utils.js';
+
+const connect = builders
+  .connect()
+  .action(async function (_context, options) {
+    if (!options?.derivationPath) {
+      throw new Error('Derivation Path can not be empty.');
+    }
+
+    setDerivationPath(options.derivationPath);
+
+    const result = await getSolanaAccounts();
+
+    const formatAccounts = result.accounts.map(
+      (account) =>
+        CAIP.AccountId.format({
+          address: account,
+          chainId: {
+            namespace: CAIP_NAMESPACE,
+            reference: result.chainId,
+          },
+        }) as CaipAccount
+    );
+
+    return formatAccounts;
+  })
+  .or(standardizeAndThrowLedgerError)
+  .build();
+
+const disconnect = commonBuilders.disconnect<SolanaActions>().build();
+
+const solana = new NamespaceBuilder<SolanaActions>('Solana', WALLET_ID)
+  .action(connect)
+  .action(disconnect)
+  .build();
+
+export { solana };

package/src/provider.ts

@@ -0,0 +1,22 @@
+import { ProviderBuilder } from '@rango-dev/wallets-core';
+
+import { metadata, WALLET_ID } from './constants.js';
+import { evm } from './namespaces/evm.js';
+import { solana } from './namespaces/solana.js';
+import { ledger as ledgerInstance } from './utils.js';
+
+const buildProvider = () =>
+  new ProviderBuilder(WALLET_ID)
+    .init(function (context) {
+      const [, setState] = context.state();
+
+      if (ledgerInstance()) {
+        setState('installed', true);
+      }
+    })
+    .config('metadata', metadata)
+    .add('solana', solana)
+    .add('evm', evm)
+    .build();
+
+export { buildProvider };

package/src/signer.ts

@@ -0,0 +1,13 @@
+import type { SignerFactory } from 'rango-types';
+
+import { DefaultSignerFactory, TransactionType as TxType } from 'rango-types';
+
+import { EthereumSigner } from './signers/ethereum';
+import { SolanaSigner } from './signers/solana';
+
+export default async function getSigners(): Promise<SignerFactory> {
+  const signers = new DefaultSignerFactory();
+  signers.registerSigner(TxType.EVM, new EthereumSigner());
+  signers.registerSigner(TxType.SOLANA, new SolanaSigner());
+  return signers;
+}

package/src/signers/ethereum.ts

@@ -0,0 +1,107 @@
+import type { TransactionLike } from 'ethers';
+import type { GenericSigner } from 'rango-types';
+import type { EvmTransaction } from 'rango-types/mainApi';
+
+import {
+  DEFAULT_ETHEREUM_RPC_URL,
+  dynamicImportWithRefinedError,
+} from '@rango-dev/wallets-shared';
+import { JsonRpcProvider, Transaction } from 'ethers';
+import { SignerError, SignerErrorCode } from 'rango-types';
+
+import { getDerivationPath } from '../state.js';
+import {
+  getLedgerError,
+  transportConnect,
+  transportDisconnect,
+} from '../utils.js';
+
+export class EthereumSigner implements GenericSigner<EvmTransaction> {
+  async signMessage(msg: string): Promise<string> {
+    try {
+      const transport = await transportConnect();
+      const LedgerAppEth = (
+        await dynamicImportWithRefinedError(
+          async () => await import('@ledgerhq/hw-app-eth')
+        )
+      ).default;
+      const eth = new LedgerAppEth(transport);
+
+      const result = await eth.signPersonalMessage(
+        getDerivationPath(),
+        Buffer.from(msg).toString('hex')
+      );
+      // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+      let v = (result['v'] - 27).toString(16);
+      if (v.length < 2) {
+        v = '0' + v;
+      }
+      return '0x' + result['r'] + result['s'] + v;
+    } catch (error) {
+      throw new SignerError(SignerErrorCode.SIGN_TX_ERROR, undefined, error);
+    }
+  }
+
+  async signAndSendTx(
+    tx: EvmTransaction,
+    fromAddress: string,
+    chainId: string | null
+  ): Promise<{ hash: string }> {
+    try {
+      const provider = new JsonRpcProvider(DEFAULT_ETHEREUM_RPC_URL); // Provider to broadcast transaction
+
+      const transactionCount = await provider.getTransactionCount(fromAddress); // Get nonce
+
+      const transaction: TransactionLike<string> = {
+        to: tx.to,
+        gasPrice: tx.gasPrice,
+        gasLimit: tx.gasLimit,
+        nonce: transactionCount,
+        chainId: chainId,
+        data: tx.data,
+        value: tx.value,
+        maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+        maxFeePerGas: tx.maxFeePerGas,
+      };
+
+      const unsignedTx =
+        Transaction.from(transaction).unsignedSerialized.substring(2); // Create unsigned transaction
+
+      const transport = await transportConnect();
+      const LedgerHqAppEth = await dynamicImportWithRefinedError(
+        async () => await import('@ledgerhq/hw-app-eth')
+      );
+
+      const LedgerAppEth = LedgerHqAppEth.default;
+      const eth = new LedgerAppEth(transport);
+
+      const resolution = await LedgerHqAppEth.ledgerService.resolveTransaction(
+        unsignedTx,
+        {},
+        {}
+      ); // metadata necessary to allow the device to clear sign information
+      const signature = await eth.signTransaction(
+        getDerivationPath(),
+        unsignedTx,
+        resolution
+      );
+
+      const signedTx = Transaction.from({
+        ...transaction,
+        signature: {
+          r: '0x' + signature.r,
+          s: '0x' + signature.s,
+          v: parseInt(signature.v),
+        },
+      }).serialized;
+
+      const broadcastResult = await provider.broadcastTransaction(signedTx);
+
+      return { hash: broadcastResult.hash };
+    } catch (error) {
+      throw getLedgerError(error);
+    } finally {
+      await transportDisconnect();
+    }
+  }
+}