@faremeter/wallet-ledger 0.1.1

package/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

package/dist/src/evm.d.ts

@@ -0,0 +1,3 @@
+import type { LedgerEvmWallet } from "./types.js";
+export declare function createLedgerEvmWallet(network: string, 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":"AAeA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AA+B/C,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,eAAe,CAAC,CAqK1B"}

package/dist/src/evm.js

@@ -0,0 +1,154 @@
+import { createWalletClient, http, hashDomain, hashStruct, } from "viem";
+import { baseSepolia, mainnet, sepolia } from "viem/chains";
+import Eth from "@ledgerhq/hw-app-eth/lib-es/Eth.js";
+import { type } from "arktype";
+import { createTransport } from "./transport.js";
+const NETWORK_CONFIGS = new Map([
+    [
+        "base-sepolia",
+        {
+            chain: baseSepolia,
+            rpcUrl: "https://sepolia.base.org",
+        },
+    ],
+    [
+        "ethereum",
+        {
+            chain: mainnet,
+            rpcUrl: "https://ethereum-rpc.publicnode.com",
+        },
+    ],
+    [
+        "sepolia",
+        {
+            chain: sepolia,
+            rpcUrl: "https://ethereum-sepolia-rpc.publicnode.com",
+        },
+    ],
+]);
+export async function createLedgerEvmWallet(network, derivationPath) {
+    const config = NETWORK_CONFIGS.get(network);
+    if (!config) {
+        throw new Error(`Unsupported network: ${network}. Supported networks: ${Array.from(NETWORK_CONFIGS.keys()).join(", ")}`);
+    }
+    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: config.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,
+                });
+                console.log("\nEIP-712 hashes calculated:");
+                console.log("  Domain separator:", domainSeparator);
+                console.log("  Message hash:", messageHash);
+                console.log("\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) {
+                console.error("EIP-712 signing failed:", error);
+                throw error;
+            }
+        },
+    };
+    const client = createWalletClient({
+        account: ledgerAccount,
+        chain: config.chain,
+        transport: http(config.rpcUrl),
+    });
+    return {
+        network,
+        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,5 @@
+export { createLedgerEvmWallet } from "./evm.js";
+export { createLedgerSolanaWallet } from "./solana.js";
+export { selectLedgerAccount } from "./utils.js";
+export type { LedgerEvmWallet, LedgerSolanaWallet } from "./types.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"}

package/dist/src/index.js

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

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":"AAAA,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,55 @@
+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"))) {
+                console.log(`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,22 @@
+import type { Hex, WalletClient, TransactionSerializable, TypedDataDefinition } from "viem";
+import type { PublicKey, VersionedTransaction } from "@solana/web3.js";
+import type Transport from "@ledgerhq/hw-transport";
+export interface LedgerEvmWallet {
+    network: string;
+    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>;
+}
+//# 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,EACpB,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,OAAO,EAAE,MAAM,CAAC;IAChB,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"}

package/dist/src/types.js

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

package/dist/src/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function selectLedgerAccount(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":"AAaA,wBAAsB,mBAAmB,CACvC,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,CAkEnD"}

package/dist/src/utils.js

@@ -0,0 +1,72 @@
+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(type, numAccounts = 5) {
+    const isEvm = type === "evm";
+    console.log(`\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 });
+                console.log(`${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 });
+                console.log(`${i + 1}. ${address}`);
+            }
+        }
+    }
+    finally {
+        await transport.close();
+    }
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const selection = await new Promise((resolve) => {
+        rl.question(`\nSelect account (1-${numAccounts}): `, resolve);
+    });
+    rl.close();
+    const index = parseInt(selection) - 1;
+    if (index < 0 || index >= accounts.length) {
+        console.log("Invalid selection");
+        return null;
+    }
+    return accounts[index] ?? null;
+}