@faremeter/wallet-ledger 0.10.1 → 0.10.2

package/dist/src/evm.d.ts

@@ -0,0 +1,4 @@
+import { type Chain } from "viem";
+import type { LedgerEvmWallet, UserInterface } from "./types.js";
+export declare function createLedgerEvmWallet(ui: UserInterface, chain: Chain, derivationPath: string): Promise<LedgerEvmWallet>;
+//# sourceMappingURL=evm.d.ts.map

package/dist/src/evm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evm.d.ts","sourceRoot":"","sources":["../../src/evm.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,KAAK,EAMX,MAAM,MAAM,CAAC;AAId,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE9D,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,aAAa,EACjB,KAAK,EAAE,KAAK,EACZ,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,eAAe,CAAC,CA4J1B"}

package/dist/src/evm.js

@@ -0,0 +1,126 @@
+import { createWalletClient, http, hashDomain, hashStruct, } from "viem";
+import Eth from "@ledgerhq/hw-app-eth/lib-es/Eth.js";
+import { type } from "arktype";
+import { createTransport } from "./transport.js";
+export async function createLedgerEvmWallet(ui, chain, derivationPath) {
+    const transport = await createTransport();
+    const eth = new Eth(transport);
+    const { address } = await eth.getAddress(derivationPath);
+    const formattedAddress = (address.startsWith("0x") ? address : `0x${address}`).toLowerCase();
+    const ledgerAccount = {
+        address: formattedAddress,
+        publicKey: formattedAddress,
+        type: "local",
+        source: "custom",
+        signMessage: async ({ message }) => {
+            let messageToSign;
+            if (typeof message === "string") {
+                messageToSign = Buffer.from(message).toString("hex");
+            }
+            else if (message && typeof message === "object" && "raw" in message) {
+                const raw = message.raw;
+                messageToSign =
+                    typeof raw === "string"
+                        ? raw.slice(2)
+                        : Buffer.from(raw).toString("hex");
+            }
+            else {
+                messageToSign = Buffer.from(String(message)).toString("hex");
+            }
+            const result = await eth.signPersonalMessage(derivationPath, messageToSign);
+            const signature = `0x${result.r}${result.s}${result.v.toString(16).padStart(2, "0")}`;
+            return signature;
+        },
+        signTransaction: async (transaction) => {
+            const toHex = (v, defaultValue) => v ? `0x${v.toString(16)}` : defaultValue;
+            const tx = {
+                to: transaction.to,
+                value: toHex(transaction.value, "0x0"),
+                data: transaction.data ?? "0x", // 0x is valid encoding for empty data in EVM
+                nonce: toHex(transaction.nonce, "0x0"),
+                gasLimit: toHex(transaction.gas, "0x5208"),
+                gasPrice: toHex(transaction.gasPrice),
+                maxFeePerGas: toHex(transaction.maxFeePerGas),
+                maxPriorityFeePerGas: toHex(transaction.maxPriorityFeePerGas),
+                chainId: chain.id,
+            };
+            const result = await eth.signTransaction(derivationPath, JSON.stringify(tx));
+            const signature = `0x${result.r}${result.s}${result.v}`;
+            return signature;
+        },
+        signTypedData: async (parameters) => {
+            const typedDataParams = type({
+                "domain?": {
+                    "name?": "string",
+                    "version?": "string",
+                    "chainId?": "number",
+                    "verifyingContract?": "string",
+                    "salt?": "string",
+                },
+                types: "object",
+                primaryType: "string",
+                message: "object",
+            });
+            const validated = typedDataParams.assert(parameters);
+            const { domain, types, primaryType, message } = validated;
+            try {
+                // Use EIP-712 hashed message approach. This calculates the domain
+                // separator and message hash separately and sends them to the Ledger
+                // for signing.
+                // Build types with EIP712Domain
+                const typesWithDomain = {
+                    EIP712Domain: [
+                        ...(domain?.name ? [{ name: "name", type: "string" }] : []),
+                        ...(domain?.version ? [{ name: "version", type: "string" }] : []),
+                        ...(domain?.chainId ? [{ name: "chainId", type: "uint256" }] : []),
+                        ...(domain?.verifyingContract
+                            ? [{ name: "verifyingContract", type: "address" }]
+                            : []),
+                    ],
+                    ...types,
+                };
+                // Calculate hashes using viem
+                const domainSeparator = hashDomain({
+                    domain: domain ?? {},
+                    types: typesWithDomain,
+                });
+                // types without domain for message hash
+                const messageHash = hashStruct({
+                    data: message,
+                    primaryType,
+                    types,
+                });
+                ui.message("\nEIP-712 hashes calculated:");
+                ui.message(`  Domain separator: ${domainSeparator}`);
+                ui.message(`  Message hash: ${messageHash}`);
+                ui.message(`\nPlease approve the transaction on your Ledger device...`);
+                const result = await eth.signEIP712HashedMessage(derivationPath, domainSeparator.slice(2), messageHash.slice(2));
+                const signature = `0x${result.r}${result.s}${result.v.toString(16).padStart(2, "0")}`;
+                return signature;
+            }
+            catch (error) {
+                ui.message(`EIP-712 signing failed: ${error}`);
+                throw error;
+            }
+        },
+    };
+    const client = createWalletClient({
+        account: ledgerAccount,
+        chain: chain,
+        transport: http(chain.rpcUrls.default.http[0]),
+    });
+    return {
+        chain,
+        address: formattedAddress,
+        client,
+        signTransaction: async (tx) => {
+            return await ledgerAccount.signTransaction(tx);
+        },
+        signTypedData: async (params) => {
+            return await ledgerAccount.signTypedData(params);
+        },
+        disconnect: async () => {
+            await transport.close();
+        },
+    };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export { createLedgerEvmWallet } from "./evm.js";
+export { createLedgerSolanaWallet } from "./solana.js";
+export { selectLedgerAccount } from "./utils.js";
+export type { LedgerEvmWallet, LedgerSolanaWallet } from "./types.js";
+export * from "./interface.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,OAAO,CAAC;AAC9C,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAC9C,YAAY,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AACnE,cAAc,aAAa,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,4 @@
+export { createLedgerEvmWallet } from "./evm.js";
+export { createLedgerSolanaWallet } from "./solana.js";
+export { selectLedgerAccount } from "./utils.js";
+export * from "./interface.js";

package/dist/src/interface.d.ts

@@ -0,0 +1,10 @@
+export type createReadlineInterfaceArgs = {
+    stdin: NodeJS.ReadableStream;
+    stdout: NodeJS.WritableStream;
+};
+export declare function createReadlineInterface(args: createReadlineInterfaceArgs): Promise<{
+    message: (msg: string) => undefined;
+    question: (q: string) => Promise<string>;
+    close: () => Promise<void>;
+}>;
+//# sourceMappingURL=interface.d.ts.map

package/dist/src/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/interface.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,2BAA2B,GAAG;IACxC,KAAK,EAAE,MAAM,CAAC,cAAc,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;CAC/B,CAAC;AAEF,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,2BAA2B;mBAShB,MAAM;kBACD,MAAM;;GAM7B"}

package/dist/src/interface.js

@@ -0,0 +1,14 @@
+export async function createReadlineInterface(args) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+        input: args.stdin,
+        output: args.stdout,
+    });
+    return {
+        message: (msg) => void args.stdout.write(msg + "\n"),
+        question: async (q) => new Promise((resolve) => {
+            rl.question(q, resolve);
+        }),
+        close: async () => rl.close(),
+    };
+}

package/dist/src/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const logger: import("@logtape/logtape").Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/src/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/logger.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,mCAA4C,CAAC"}

package/dist/src/logger.js

@@ -0,0 +1,2 @@
+import { getLogger } from "@logtape/logtape";
+export const logger = getLogger(["faremeter", "wallet-ledger"]);

package/dist/src/solana.d.ts

@@ -0,0 +1,3 @@
+import type { LedgerSolanaWallet } from "./types.js";
+export declare function createLedgerSolanaWallet(network: string, derivationPath: string): Promise<LedgerSolanaWallet>;
+//# sourceMappingURL=solana.d.ts.map

package/dist/src/solana.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solana.d.ts","sourceRoot":"","sources":["../../src/solana.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,kBAAkB,CAAC,CA0B7B"}

package/dist/src/solana.js

@@ -0,0 +1,22 @@
+import { PublicKey, VersionedTransaction } from "@solana/web3.js";
+import Solana from "@ledgerhq/hw-app-solana/lib-es/Solana.js";
+import { createTransport } from "./transport.js";
+export async function createLedgerSolanaWallet(network, derivationPath) {
+    const transport = await createTransport();
+    const solana = new Solana(transport);
+    const { address } = await solana.getAddress(derivationPath);
+    const publicKey = new PublicKey(address);
+    return {
+        network,
+        publicKey,
+        updateTransaction: async (tx) => {
+            const message = tx.message.serialize();
+            const signature = await solana.signTransaction(derivationPath, Buffer.from(message));
+            tx.addSignature(publicKey, signature.signature);
+            return tx;
+        },
+        disconnect: async () => {
+            await transport.close();
+        },
+    };
+}

package/dist/src/transport.d.ts

@@ -0,0 +1,4 @@
+import type Transport from "@ledgerhq/hw-transport";
+export declare function translateLedgerError(error: unknown): Error;
+export declare function createTransport(maxRetries?: number): Promise<Transport>;
+//# sourceMappingURL=transport.d.ts.map

package/dist/src/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/transport.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,SAAS,MAAM,wBAAwB,CAAC;AAcpD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAoB1D;AAED,wBAAsB,eAAe,CAAC,UAAU,SAAI,GAAG,OAAO,CAAC,SAAS,CAAC,CAyCxE"}

package/dist/src/transport.js

@@ -0,0 +1,56 @@
+import { logger } from "./logger.js";
+const LEDGER_ERRORS = {
+    "0x5515": "Ledger is locked. Please unlock your device.",
+    "0x6511": "Please unlock your Ledger and open the correct app.",
+    "0x6d00": "Wrong app open. Please open the correct app.",
+    "0x6d02": "No app open. Please open the correct app on your Ledger.",
+    "0x6e00": "Wrong app open. Please open the correct app on your Ledger.",
+    "0x6985": "Transaction rejected on Ledger device.",
+    "0x6a80": "Incorrect data. Please make sure the correct app is open on your Ledger.",
+    "0x6a83": "Wrong app open. Please open the correct app on your Ledger.",
+};
+export function translateLedgerError(error) {
+    const message = String(error instanceof Error ? error.message : error);
+    const hexMatch = /0x[0-9a-fA-F]{4}/.exec(message);
+    if (hexMatch && LEDGER_ERRORS[hexMatch[0]]) {
+        return new Error(LEDGER_ERRORS[hexMatch[0]]);
+    }
+    // Check for common connection errors
+    if (message.includes("NoDevice")) {
+        return new Error("No Ledger device found. Please connect your Ledger and unlock it.");
+    }
+    if (message.includes("Device busy")) {
+        return new Error("Ledger is in use by another app. Close Ledger Live.");
+    }
+    return error instanceof Error ? error : new Error(message);
+}
+export async function createTransport(maxRetries = 3) {
+    let lastError;
+    for (let i = 0; i < maxRetries; i++) {
+        try {
+            const isBrowser = typeof globalThis !== "undefined" && "window" in globalThis;
+            if (isBrowser) {
+                const { default: TransportWebUSB } = await import("@ledgerhq/hw-transport-webusb");
+                return await TransportWebUSB.create();
+            }
+            else {
+                const mod = await import("@ledgerhq/hw-transport-node-hid");
+                const TransportNodeHid = mod.default || mod;
+                return await TransportNodeHid.open("");
+            }
+        }
+        catch (error) {
+            const translatedError = translateLedgerError(error);
+            lastError = translatedError;
+            // Retry on generic USB errors
+            const errorMessage = translatedError.message;
+            if (i < maxRetries - 1 &&
+                (errorMessage.includes("USB") || errorMessage.includes("device"))) {
+                logger.warning(`USB connection attempt ${i + 1} failed, retrying...`);
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+                continue;
+            }
+        }
+    }
+    throw lastError ?? new Error("Failed to connect to Ledger device");
+}

package/dist/src/types.d.ts

@@ -0,0 +1,27 @@
+import type { Hex, WalletClient, TransactionSerializable, TypedDataDefinition, Chain } from "viem";
+import type { PublicKey, VersionedTransaction } from "@solana/web3.js";
+import type Transport from "@ledgerhq/hw-transport";
+export interface LedgerEvmWallet {
+    chain: Chain;
+    address: Hex;
+    client: WalletClient;
+    signTransaction: (tx: TransactionSerializable) => Promise<Hex>;
+    signTypedData: (params: TypedDataDefinition) => Promise<Hex>;
+    disconnect: () => Promise<void>;
+}
+export interface LedgerSolanaWallet {
+    network: string;
+    publicKey: PublicKey;
+    updateTransaction: (tx: VersionedTransaction) => Promise<VersionedTransaction>;
+    disconnect: () => Promise<void>;
+}
+export interface LedgerTransportWrapper {
+    transport: Transport;
+    close: () => Promise<void>;
+}
+export interface UserInterface {
+    message: (msg: string) => void;
+    question: (prompt: string) => Promise<string>;
+    close: () => Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,GAAG,EACH,YAAY,EACZ,uBAAuB,EACvB,mBAAmB,EACnB,KAAK,EACN,MAAM,MAAM,CAAC;AACd,OAAO,KAAK,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvE,OAAO,KAAK,SAAS,MAAM,wBAAwB,CAAC;AAEpD,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,GAAG,CAAC;IACb,MAAM,EAAE,YAAY,CAAC;IACrB,eAAe,EAAE,CAAC,EAAE,EAAE,uBAAuB,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IAC/D,aAAa,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IAC7D,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,iBAAiB,EAAE,CACjB,EAAE,EAAE,oBAAoB,KACrB,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACnC,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,SAAS,CAAC;IACrB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9C,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B"}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/utils.d.ts

@@ -0,0 +1,6 @@
+import type { UserInterface } from "./types.js";
+export declare function selectLedgerAccount(ui: UserInterface, type: "evm" | "solana", numAccounts?: number): Promise<{
+    path: string;
+    address: string;
+} | null>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAU7C,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,aAAa,EACjB,IAAI,EAAE,KAAK,GAAG,QAAQ,EACtB,WAAW,SAAI,GACd,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAyDnD"}

package/dist/src/utils.js

@@ -0,0 +1,64 @@
+import Eth from "@ledgerhq/hw-app-eth/lib-es/Eth.js";
+import Solana from "@ledgerhq/hw-app-solana/lib-es/Solana.js";
+import { PublicKey } from "@solana/web3.js";
+import { createTransport, translateLedgerError } from "./transport.js";
+function evmDerivationPath(index) {
+    return `m/44'/60'/${index}'/0/0`;
+}
+function solanaDerivationPath(index) {
+    return `44'/501'/${index}'`;
+}
+export async function selectLedgerAccount(ui, type, numAccounts = 5) {
+    const isEvm = type === "evm";
+    ui.message(`\nScanning first ${numAccounts} ${isEvm ? "Ethereum" : "Solana"} accounts...`);
+    const accounts = [];
+    const transport = await createTransport();
+    try {
+        if (isEvm) {
+            const eth = new Eth(transport);
+            for (let i = 0; i < numAccounts; i++) {
+                const path = evmDerivationPath(i);
+                let result;
+                try {
+                    result = await eth.getAddress(path, false);
+                }
+                catch (error) {
+                    throw translateLedgerError(error);
+                }
+                const address = result.address;
+                const normalizedAddress = address.startsWith("0x")
+                    ? address
+                    : `0x${address}`;
+                accounts.push({ path, address: normalizedAddress });
+                ui.message(`${i + 1}. ${normalizedAddress}`);
+            }
+        }
+        else {
+            const solana = new Solana(transport);
+            for (let i = 0; i < numAccounts; i++) {
+                const path = solanaDerivationPath(i);
+                let result;
+                try {
+                    result = await solana.getAddress(path, false);
+                }
+                catch (error) {
+                    throw translateLedgerError(error);
+                }
+                const publicKey = new PublicKey(result.address);
+                const address = publicKey.toBase58();
+                accounts.push({ path, address });
+                ui.message(`${i + 1}. ${address}`);
+            }
+        }
+    }
+    finally {
+        await transport.close();
+    }
+    const selection = await ui.question(`\nSelect account (1-${numAccounts}): `);
+    const index = parseInt(selection) - 1;
+    if (index < 0 || index >= accounts.length) {
+        ui.message("Invalid selection");
+        return null;
+    }
+    return accounts[index] ?? null;
+}