@etherscan-npm/cli 1.0.1 → 1.0.2

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Etherscan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Etherscan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -54,6 +54,8 @@ npx @etherscan-npm/cli version
 
 The npm package downloads the matching native release archive and verifies its SHA-256 checksum during installation. Lifecycle scripts must be enabled.
 
+> The package is currently published as `@etherscan-npm/cli` while the `@etherscan` npm scope is being transferred. The `etherscan` command is unchanged.
+
 ### Installation script — macOS and Linux
 
 ```sh

package/npm/postinstall.js

@@ -1,58 +1,58 @@
-"use strict";
-
-const fs = require("node:fs");
-const path = require("node:path");
-const { spawnSync } = require("node:child_process");
-const packageInfo = require("../package.json");
-
-const packageRoot = path.resolve(__dirname, "..");
-const installDir = path.join(packageRoot, "vendor");
-const version = `v${packageInfo.version}`;
-
-let command;
-let args;
-if (process.platform === "win32") {
-  command = "powershell.exe";
-  args = [
-    "-NoLogo",
-    "-NoProfile",
-    "-NonInteractive",
-    "-ExecutionPolicy",
-    "Bypass",
-    "-File",
-    path.join(packageRoot, "scripts", "install.ps1"),
-    "-Version",
-    version,
-    "-InstallDir",
-    installDir,
-    "-NoPathUpdate",
-  ];
-} else {
-  command = "sh";
-  args = [
-    path.join(packageRoot, "scripts", "install.sh"),
-    "--version",
-    version,
-    "--install-dir",
-    installDir,
-    "--no-path-update",
-  ];
-}
-
-const result = spawnSync(command, args, { stdio: "inherit", env: process.env });
-if (result.error) {
-  console.error(`Unable to run the Etherscan CLI installer: ${result.error.message}`);
-  process.exit(1);
-}
-if (result.status !== 0) {
-  process.exit(result.status === null ? 1 : result.status);
-}
-
-const executable = path.join(
-  installDir,
-  process.platform === "win32" ? "etherscan.exe" : "etherscan",
-);
-if (!fs.existsSync(executable)) {
-  console.error(`The installer did not create ${executable}.`);
-  process.exit(1);
-}
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const packageInfo = require("../package.json");
+
+const packageRoot = path.resolve(__dirname, "..");
+const installDir = path.join(packageRoot, "vendor");
+const version = `v${packageInfo.version}`;
+
+let command;
+let args;
+if (process.platform === "win32") {
+  command = "powershell.exe";
+  args = [
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-File",
+    path.join(packageRoot, "scripts", "install.ps1"),
+    "-Version",
+    version,
+    "-InstallDir",
+    installDir,
+    "-NoPathUpdate",
+  ];
+} else {
+  command = "sh";
+  args = [
+    path.join(packageRoot, "scripts", "install.sh"),
+    "--version",
+    version,
+    "--install-dir",
+    installDir,
+    "--no-path-update",
+  ];
+}
+
+const result = spawnSync(command, args, { stdio: "inherit", env: process.env });
+if (result.error) {
+  console.error(`Unable to run the Etherscan CLI installer: ${result.error.message}`);
+  process.exit(1);
+}
+if (result.status !== 0) {
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+const executable = path.join(
+  installDir,
+  process.platform === "win32" ? "etherscan.exe" : "etherscan",
+);
+if (!fs.existsSync(executable)) {
+  console.error(`The installer did not create ${executable}.`);
+  process.exit(1);
+}

package/npm/prepublish-check.js

@@ -1,15 +1,81 @@
-"use strict";
-
-const packageInfo = require("../package.json");
-
-try {
-  if (packageInfo.version === "0.0.0-development") {
-    throw new Error("the development placeholder version cannot be published");
-  }
-  if (!/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(packageInfo.version)) {
-    throw new Error(`invalid release version: ${packageInfo.version}`);
-  }
-} catch (error) {
-  console.error(`Refusing to publish @etherscan/cli: ${error.message}`);
-  process.exit(1);
-}
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const packageInfo = require("../package.json");
+
+const versionPattern =
+  /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+
+// npm treats these as glob metacharacters in package.json "files".
+const globPattern = /[*?[\]{}]/;
+
+function checkVersion(version) {
+  if (version === "0.0.0-development") {
+    throw new Error("the development placeholder version cannot be published");
+  }
+  if (!versionPattern.test(version)) {
+    throw new Error(`invalid release version: ${version}`);
+  }
+}
+
+// `npm pack` copies the working tree, not the committed blobs. On Windows a
+// checkout with core.autocrlf=true turns the LF blobs into CRLF, and a CRLF
+// scripts/install.sh cannot be run by /bin/sh on Linux or macOS, which is how
+// @etherscan-npm/cli@1.0.1 shipped an installer that failed on both.
+function checkFileLineEndings(filePath, label) {
+  const contents = fs.readFileSync(filePath);
+  // Skip binaries using the same NUL-byte heuristic git applies for text=auto.
+  if (contents.includes(0x00)) {
+    return;
+  }
+  if (contents.includes(0x0d)) {
+    throw new Error(`${label} contains CRLF line endings`);
+  }
+}
+
+// Checks the literal entries of package.json "files". This fails closed: npm
+// also accepts globs and directories there, and silently skipping what it cannot
+// resolve would let a future "files" edit disable the gate while leaving the
+// publish green — the same silent-pass shape that let 1.0.1 ship.
+function checkLineEndings(baseDir, files = packageInfo.files) {
+  for (const entry of files) {
+    if (globPattern.test(entry)) {
+      throw new Error(
+        `${entry} is a glob pattern; this check only understands literal file paths, so update it before publishing`,
+      );
+    }
+    const filePath = path.join(baseDir, entry);
+    let stats;
+    try {
+      stats = fs.statSync(filePath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`${entry} is listed in package.json "files" but does not exist`);
+      }
+      throw error;
+    }
+    if (stats.isDirectory()) {
+      throw new Error(
+        `${entry} is a directory; this check only understands literal file paths, so update it before publishing`,
+      );
+    }
+    checkFileLineEndings(filePath, entry);
+  }
+}
+
+function main() {
+  checkVersion(packageInfo.version);
+  checkLineEndings(path.resolve(__dirname, ".."));
+}
+
+module.exports = { checkVersion, checkFileLineEndings, checkLineEndings };
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.error(`Refusing to publish @etherscan/cli: ${error.message}`);
+    process.exit(1);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etherscan-npm/cli",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Command-line client and interactive explorer for the Etherscan V2 API",
   "license": "MIT",
   "homepage": "https://github.com/etherscan/etherscan-cli",
@@ -19,7 +19,8 @@
     "postinstall": "node npm/postinstall.js",
     "prepublishOnly": "node npm/prepublish-check.js",
     "test:package": "npm pack --dry-run",
-    "test:release": "node npm/publish.test.js"
+    "test:release": "node npm/publish.test.js",
+    "test:eol": "node npm/check-tarball-eol.js"
   },
   "files": [
     "npm/bin/etherscan.js",

package/scripts/install.ps1

@@ -1,262 +1,262 @@
-[CmdletBinding()]
-param(
-    [string]$Version = $env:ETHERSCAN_VERSION,
-    [string]$InstallDir = $env:ETHERSCAN_INSTALL_DIR,
-    [switch]$NoPathUpdate,
-    [int]$WaitForProcessId = 0,
-    [switch]$CleanupScript
-)
-
-$ErrorActionPreference = "Stop"
-$ProgressPreference = "SilentlyContinue"
-
-$Repository = "etherscan/etherscan-cli"
-$DownloadBaseUrl = $env:ETHERSCAN_INSTALL_TEST_DOWNLOAD_BASE_URL
-
-function Get-EtherscanArchitecture {
-    $architecture = $env:PROCESSOR_ARCHITEW6432
-    if ([string]::IsNullOrWhiteSpace($architecture)) {
-        $architecture = $env:PROCESSOR_ARCHITECTURE
-    }
-
-    switch -Regex ($architecture) {
-        "^(AMD64|x86_64)$" { return "amd64" }
-        "^(ARM64|aarch64)$" { return "arm64" }
-        default { throw "Unsupported Windows architecture: $architecture. Etherscan CLI supports amd64 and arm64." }
-    }
-}
-
-function Get-GitHubApiHeaders {
-    $headers = @{
-        Accept = "application/vnd.github+json"
-        "User-Agent" = "etherscan-cli-installer"
-        "X-GitHub-Api-Version" = "2022-11-28"
-    }
-    if (-not [string]::IsNullOrWhiteSpace($env:ETHERSCAN_GITHUB_TOKEN)) {
-        $headers.Authorization = "Bearer $($env:ETHERSCAN_GITHUB_TOKEN)"
-    }
-    return $headers
-}
-
-function Resolve-EtherscanVersion {
-    param([string]$RequestedVersion)
-
-    if (-not [string]::IsNullOrWhiteSpace($RequestedVersion) -and $RequestedVersion -ne "latest") {
-        $tag = if ($RequestedVersion.StartsWith("v")) { $RequestedVersion } else { "v$RequestedVersion" }
-    }
-    else {
-        if (-not [string]::IsNullOrWhiteSpace($DownloadBaseUrl)) {
-            throw "A version is required when the installer test download source is used."
-        }
-        $release = Invoke-RestMethod `
-            -Uri "https://api.github.com/repos/$Repository/releases/latest" `
-            -Headers (Get-GitHubApiHeaders)
-        $tag = [string]$release.tag_name
-    }
-
-    if ($tag -notmatch '^v[0-9]+\.[0-9]+\.[0-9]+(?:[-+][0-9A-Za-z.-]+)?$') {
-        throw "Invalid release version: $tag"
-    }
-
-    return @{
-        Tag = $tag
-        Version = $tag.Substring(1)
-    }
-}
-
-function Copy-InstallerFile {
-    param(
-        [string]$Base,
-        [string]$Name,
-        [string]$Destination
-    )
-
-    if (Test-Path -LiteralPath $Base -PathType Container) {
-        Copy-Item -LiteralPath (Join-Path $Base $Name) -Destination $Destination
-        return
-    }
-
-    $uri = "$($Base.TrimEnd('/'))/$Name"
-    $parsedUri = [Uri]$uri
-    if ($parsedUri.Scheme -ne "https") {
-        throw "Remote downloads must use HTTPS: $uri"
-    }
-
-    $headers = @{
-        "User-Agent" = "etherscan-cli-installer"
-    }
-    if ($parsedUri.Host -in @("github.com", "api.github.com") -and
-        -not [string]::IsNullOrWhiteSpace($env:ETHERSCAN_GITHUB_TOKEN)) {
-        $headers.Authorization = "Bearer $($env:ETHERSCAN_GITHUB_TOKEN)"
-    }
-
-    Invoke-WebRequest -Uri $uri -OutFile $Destination -Headers $headers -UseBasicParsing
-}
-
-function Get-SHA256FileHash {
-    param([string]$Path)
-
-    $sha256 = [Security.Cryptography.SHA256]::Create()
-    try {
-        $stream = [IO.File]::OpenRead($Path)
-        try {
-            return ([BitConverter]::ToString($sha256.ComputeHash($stream))).Replace("-", "").ToLowerInvariant()
-        }
-        finally {
-            $stream.Dispose()
-        }
-    }
-    finally {
-        $sha256.Dispose()
-    }
-}
-
-function Add-EtherscanToUserPath {
-    param([string]$Directory)
-
-    $fullDirectory = [IO.Path]::GetFullPath($Directory).TrimEnd('\')
-    $userPath = [Environment]::GetEnvironmentVariable("Path", "User")
-    $entries = @($userPath -split ';' | Where-Object { -not [string]::IsNullOrWhiteSpace($_) })
-    $alreadyPresent = $entries | Where-Object {
-        try {
-            $expandedEntry = [Environment]::ExpandEnvironmentVariables($_)
-            [IO.Path]::GetFullPath($expandedEntry).TrimEnd('\').Equals($fullDirectory, [StringComparison]::OrdinalIgnoreCase)
-        }
-        catch {
-            $_.TrimEnd('\').Equals($fullDirectory, [StringComparison]::OrdinalIgnoreCase)
-        }
-    }
-
-    if (-not $alreadyPresent) {
-        $newUserPath = if ([string]::IsNullOrWhiteSpace($userPath)) {
-            $fullDirectory
-        }
-        else {
-            "$($userPath.TrimEnd(';'));$fullDirectory"
-        }
-        [Environment]::SetEnvironmentVariable("Path", $newUserPath, "User")
-        Write-Host "Added $fullDirectory to your user PATH."
-    }
-
-    $processEntries = @($env:Path -split ';')
-    if (-not ($processEntries | Where-Object { $_.TrimEnd('\').Equals($fullDirectory, [StringComparison]::OrdinalIgnoreCase) })) {
-        $env:Path = "$env:Path;$fullDirectory"
-    }
-}
-
-if ($env:OS -ne "Windows_NT") {
-    throw "This installer supports Windows only. Use install.sh on macOS or Linux."
-}
-
-if ([string]::IsNullOrWhiteSpace($InstallDir)) {
-    $localAppData = [Environment]::GetFolderPath([Environment+SpecialFolder]::LocalApplicationData)
-    $InstallDir = Join-Path $localAppData "Programs\Etherscan\bin"
-}
-if ($InstallDir.Contains(';')) {
-    throw "The installation directory cannot contain a semicolon."
-}
-if ($InstallDir.IndexOfAny([char[]]"`r`n") -ge 0) {
-    throw "The installation directory cannot contain a line break."
-}
-if ($WaitForProcessId -gt 0) {
-    Wait-Process -Id $WaitForProcessId -ErrorAction SilentlyContinue
-}
-
-$resolved = Resolve-EtherscanVersion -RequestedVersion $Version
-$architecture = Get-EtherscanArchitecture
-$archiveName = "etherscan_$($resolved.Version)_windows_$architecture.zip"
-$baseUrl = if ([string]::IsNullOrWhiteSpace($DownloadBaseUrl)) {
-    "https://github.com/$Repository/releases/download/$($resolved.Tag)"
-}
-else {
-    $DownloadBaseUrl
-}
-
-$tempDirectory = Join-Path ([IO.Path]::GetTempPath()) "etherscan-install-$PID-$([Guid]::NewGuid().ToString('N'))"
-$archivePath = Join-Path $tempDirectory $archiveName
-$checksumPath = Join-Path $tempDirectory "checksums.txt"
-$sourceExecutable = Join-Path $tempDirectory "etherscan.exe"
-
-try {
-    New-Item -ItemType Directory -Path $tempDirectory -Force | Out-Null
-
-    Write-Host "Downloading Etherscan CLI $($resolved.Version) for windows/$architecture..."
-    Copy-InstallerFile -Base $baseUrl -Name $archiveName -Destination $archivePath
-    Copy-InstallerFile -Base $baseUrl -Name "checksums.txt" -Destination $checksumPath
-
-    $pattern = '^([0-9A-Fa-f]{64})\s+\*?' + [Regex]::Escape($archiveName) + '$'
-    $checksumLine = Get-Content -LiteralPath $checksumPath | Where-Object { $_ -match $pattern } | Select-Object -First 1
-    if (-not $checksumLine -or $checksumLine -notmatch $pattern) {
-        throw "No checksum was published for $archiveName."
-    }
-
-    $expectedHash = $Matches[1].ToLowerInvariant()
-    $actualHash = Get-SHA256FileHash -Path $archivePath
-    if ($actualHash -ne $expectedHash) {
-        throw "Checksum verification failed for $archiveName. Expected $expectedHash, received $actualHash."
-    }
-
-    Add-Type -AssemblyName System.IO.Compression.FileSystem
-    $zip = [IO.Compression.ZipFile]::OpenRead($archivePath)
-    try {
-        $executableEntries = @($zip.Entries | Where-Object { $_.FullName.Replace('\', '/') -eq "etherscan.exe" })
-        if ($executableEntries.Count -ne 1) {
-            throw "$archiveName must contain exactly one root-level etherscan.exe."
-        }
-
-        $inputStream = $executableEntries[0].Open()
-        $outputStream = [IO.File]::Create($sourceExecutable)
-        try {
-            $inputStream.CopyTo($outputStream)
-        }
-        finally {
-            $outputStream.Dispose()
-            $inputStream.Dispose()
-        }
-    }
-    finally {
-        $zip.Dispose()
-    }
-
-    New-Item -ItemType Directory -Path $InstallDir -Force | Out-Null
-    $targetExecutable = Join-Path $InstallDir "etherscan.exe"
-    $stagedExecutable = Join-Path $InstallDir ".etherscan.exe.new-$PID"
-    $backupExecutable = Join-Path $InstallDir ".etherscan.exe.old-$PID"
-    Copy-Item -LiteralPath $sourceExecutable -Destination $stagedExecutable -Force
-
-    try {
-        if (Test-Path -LiteralPath $targetExecutable) {
-            Move-Item -LiteralPath $targetExecutable -Destination $backupExecutable -Force
-        }
-        Move-Item -LiteralPath $stagedExecutable -Destination $targetExecutable -Force
-        Remove-Item -LiteralPath $backupExecutable -Force -ErrorAction SilentlyContinue
-    }
-    catch {
-        Remove-Item -LiteralPath $stagedExecutable -Force -ErrorAction SilentlyContinue
-        if ((Test-Path -LiteralPath $backupExecutable) -and -not (Test-Path -LiteralPath $targetExecutable)) {
-            Move-Item -LiteralPath $backupExecutable -Destination $targetExecutable -Force
-        }
-        throw
-    }
-
-    if (-not $NoPathUpdate) {
-        Add-EtherscanToUserPath -Directory $InstallDir
-    }
-
-    Write-Host ""
-    Write-Host "Etherscan CLI $($resolved.Version) installed successfully."
-    Write-Host "Installed to: $targetExecutable"
-    if ($NoPathUpdate) {
-        Write-Host "Add $InstallDir to PATH to run etherscan from any directory."
-    }
-    else {
-        Write-Host "Run 'etherscan version' to verify the installation."
-        Write-Host "Open a new terminal if the command is not yet available."
-    }
-}
-finally {
-    Remove-Item -LiteralPath $tempDirectory -Recurse -Force -ErrorAction SilentlyContinue
-    if ($CleanupScript -and -not [string]::IsNullOrWhiteSpace($PSCommandPath)) {
-        Remove-Item -LiteralPath $PSCommandPath -Force -ErrorAction SilentlyContinue
-    }
-}
+[CmdletBinding()]
+param(
+    [string]$Version = $env:ETHERSCAN_VERSION,
+    [string]$InstallDir = $env:ETHERSCAN_INSTALL_DIR,
+    [switch]$NoPathUpdate,
+    [int]$WaitForProcessId = 0,
+    [switch]$CleanupScript
+)
+
+$ErrorActionPreference = "Stop"
+$ProgressPreference = "SilentlyContinue"
+
+$Repository = "etherscan/etherscan-cli"
+$DownloadBaseUrl = $env:ETHERSCAN_INSTALL_TEST_DOWNLOAD_BASE_URL
+
+function Get-EtherscanArchitecture {
+    $architecture = $env:PROCESSOR_ARCHITEW6432
+    if ([string]::IsNullOrWhiteSpace($architecture)) {
+        $architecture = $env:PROCESSOR_ARCHITECTURE
+    }
+
+    switch -Regex ($architecture) {
+        "^(AMD64|x86_64)$" { return "amd64" }
+        "^(ARM64|aarch64)$" { return "arm64" }
+        default { throw "Unsupported Windows architecture: $architecture. Etherscan CLI supports amd64 and arm64." }
+    }
+}
+
+function Get-GitHubApiHeaders {
+    $headers = @{
+        Accept = "application/vnd.github+json"
+        "User-Agent" = "etherscan-cli-installer"
+        "X-GitHub-Api-Version" = "2022-11-28"
+    }
+    if (-not [string]::IsNullOrWhiteSpace($env:ETHERSCAN_GITHUB_TOKEN)) {
+        $headers.Authorization = "Bearer $($env:ETHERSCAN_GITHUB_TOKEN)"
+    }
+    return $headers
+}
+
+function Resolve-EtherscanVersion {
+    param([string]$RequestedVersion)
+
+    if (-not [string]::IsNullOrWhiteSpace($RequestedVersion) -and $RequestedVersion -ne "latest") {
+        $tag = if ($RequestedVersion.StartsWith("v")) { $RequestedVersion } else { "v$RequestedVersion" }
+    }
+    else {
+        if (-not [string]::IsNullOrWhiteSpace($DownloadBaseUrl)) {
+            throw "A version is required when the installer test download source is used."
+        }
+        $release = Invoke-RestMethod `
+            -Uri "https://api.github.com/repos/$Repository/releases/latest" `
+            -Headers (Get-GitHubApiHeaders)
+        $tag = [string]$release.tag_name
+    }
+
+    if ($tag -notmatch '^v[0-9]+\.[0-9]+\.[0-9]+(?:[-+][0-9A-Za-z.-]+)?$') {
+        throw "Invalid release version: $tag"
+    }
+
+    return @{
+        Tag = $tag
+        Version = $tag.Substring(1)
+    }
+}
+
+function Copy-InstallerFile {
+    param(
+        [string]$Base,
+        [string]$Name,
+        [string]$Destination
+    )
+
+    if (Test-Path -LiteralPath $Base -PathType Container) {
+        Copy-Item -LiteralPath (Join-Path $Base $Name) -Destination $Destination
+        return
+    }
+
+    $uri = "$($Base.TrimEnd('/'))/$Name"
+    $parsedUri = [Uri]$uri
+    if ($parsedUri.Scheme -ne "https") {
+        throw "Remote downloads must use HTTPS: $uri"
+    }
+
+    $headers = @{
+        "User-Agent" = "etherscan-cli-installer"
+    }
+    if ($parsedUri.Host -in @("github.com", "api.github.com") -and
+        -not [string]::IsNullOrWhiteSpace($env:ETHERSCAN_GITHUB_TOKEN)) {
+        $headers.Authorization = "Bearer $($env:ETHERSCAN_GITHUB_TOKEN)"
+    }
+
+    Invoke-WebRequest -Uri $uri -OutFile $Destination -Headers $headers -UseBasicParsing
+}
+
+function Get-SHA256FileHash {
+    param([string]$Path)
+
+    $sha256 = [Security.Cryptography.SHA256]::Create()
+    try {
+        $stream = [IO.File]::OpenRead($Path)
+        try {
+            return ([BitConverter]::ToString($sha256.ComputeHash($stream))).Replace("-", "").ToLowerInvariant()
+        }
+        finally {
+            $stream.Dispose()
+        }
+    }
+    finally {
+        $sha256.Dispose()
+    }
+}
+
+function Add-EtherscanToUserPath {
+    param([string]$Directory)
+
+    $fullDirectory = [IO.Path]::GetFullPath($Directory).TrimEnd('\')
+    $userPath = [Environment]::GetEnvironmentVariable("Path", "User")
+    $entries = @($userPath -split ';' | Where-Object { -not [string]::IsNullOrWhiteSpace($_) })
+    $alreadyPresent = $entries | Where-Object {
+        try {
+            $expandedEntry = [Environment]::ExpandEnvironmentVariables($_)
+            [IO.Path]::GetFullPath($expandedEntry).TrimEnd('\').Equals($fullDirectory, [StringComparison]::OrdinalIgnoreCase)
+        }
+        catch {
+            $_.TrimEnd('\').Equals($fullDirectory, [StringComparison]::OrdinalIgnoreCase)
+        }
+    }
+
+    if (-not $alreadyPresent) {
+        $newUserPath = if ([string]::IsNullOrWhiteSpace($userPath)) {
+            $fullDirectory
+        }
+        else {
+            "$($userPath.TrimEnd(';'));$fullDirectory"
+        }
+        [Environment]::SetEnvironmentVariable("Path", $newUserPath, "User")
+        Write-Host "Added $fullDirectory to your user PATH."
+    }
+
+    $processEntries = @($env:Path -split ';')
+    if (-not ($processEntries | Where-Object { $_.TrimEnd('\').Equals($fullDirectory, [StringComparison]::OrdinalIgnoreCase) })) {
+        $env:Path = "$env:Path;$fullDirectory"
+    }
+}
+
+if ($env:OS -ne "Windows_NT") {
+    throw "This installer supports Windows only. Use install.sh on macOS or Linux."
+}
+
+if ([string]::IsNullOrWhiteSpace($InstallDir)) {
+    $localAppData = [Environment]::GetFolderPath([Environment+SpecialFolder]::LocalApplicationData)
+    $InstallDir = Join-Path $localAppData "Programs\Etherscan\bin"
+}
+if ($InstallDir.Contains(';')) {
+    throw "The installation directory cannot contain a semicolon."
+}
+if ($InstallDir.IndexOfAny([char[]]"`r`n") -ge 0) {
+    throw "The installation directory cannot contain a line break."
+}
+if ($WaitForProcessId -gt 0) {
+    Wait-Process -Id $WaitForProcessId -ErrorAction SilentlyContinue
+}
+
+$resolved = Resolve-EtherscanVersion -RequestedVersion $Version
+$architecture = Get-EtherscanArchitecture
+$archiveName = "etherscan_$($resolved.Version)_windows_$architecture.zip"
+$baseUrl = if ([string]::IsNullOrWhiteSpace($DownloadBaseUrl)) {
+    "https://github.com/$Repository/releases/download/$($resolved.Tag)"
+}
+else {
+    $DownloadBaseUrl
+}
+
+$tempDirectory = Join-Path ([IO.Path]::GetTempPath()) "etherscan-install-$PID-$([Guid]::NewGuid().ToString('N'))"
+$archivePath = Join-Path $tempDirectory $archiveName
+$checksumPath = Join-Path $tempDirectory "checksums.txt"
+$sourceExecutable = Join-Path $tempDirectory "etherscan.exe"
+
+try {
+    New-Item -ItemType Directory -Path $tempDirectory -Force | Out-Null
+
+    Write-Host "Downloading Etherscan CLI $($resolved.Version) for windows/$architecture..."
+    Copy-InstallerFile -Base $baseUrl -Name $archiveName -Destination $archivePath
+    Copy-InstallerFile -Base $baseUrl -Name "checksums.txt" -Destination $checksumPath
+
+    $pattern = '^([0-9A-Fa-f]{64})\s+\*?' + [Regex]::Escape($archiveName) + '$'
+    $checksumLine = Get-Content -LiteralPath $checksumPath | Where-Object { $_ -match $pattern } | Select-Object -First 1
+    if (-not $checksumLine -or $checksumLine -notmatch $pattern) {
+        throw "No checksum was published for $archiveName."
+    }
+
+    $expectedHash = $Matches[1].ToLowerInvariant()
+    $actualHash = Get-SHA256FileHash -Path $archivePath
+    if ($actualHash -ne $expectedHash) {
+        throw "Checksum verification failed for $archiveName. Expected $expectedHash, received $actualHash."
+    }
+
+    Add-Type -AssemblyName System.IO.Compression.FileSystem
+    $zip = [IO.Compression.ZipFile]::OpenRead($archivePath)
+    try {
+        $executableEntries = @($zip.Entries | Where-Object { $_.FullName.Replace('\', '/') -eq "etherscan.exe" })
+        if ($executableEntries.Count -ne 1) {
+            throw "$archiveName must contain exactly one root-level etherscan.exe."
+        }
+
+        $inputStream = $executableEntries[0].Open()
+        $outputStream = [IO.File]::Create($sourceExecutable)
+        try {
+            $inputStream.CopyTo($outputStream)
+        }
+        finally {
+            $outputStream.Dispose()
+            $inputStream.Dispose()
+        }
+    }
+    finally {
+        $zip.Dispose()
+    }
+
+    New-Item -ItemType Directory -Path $InstallDir -Force | Out-Null
+    $targetExecutable = Join-Path $InstallDir "etherscan.exe"
+    $stagedExecutable = Join-Path $InstallDir ".etherscan.exe.new-$PID"
+    $backupExecutable = Join-Path $InstallDir ".etherscan.exe.old-$PID"
+    Copy-Item -LiteralPath $sourceExecutable -Destination $stagedExecutable -Force
+
+    try {
+        if (Test-Path -LiteralPath $targetExecutable) {
+            Move-Item -LiteralPath $targetExecutable -Destination $backupExecutable -Force
+        }
+        Move-Item -LiteralPath $stagedExecutable -Destination $targetExecutable -Force
+        Remove-Item -LiteralPath $backupExecutable -Force -ErrorAction SilentlyContinue
+    }
+    catch {
+        Remove-Item -LiteralPath $stagedExecutable -Force -ErrorAction SilentlyContinue
+        if ((Test-Path -LiteralPath $backupExecutable) -and -not (Test-Path -LiteralPath $targetExecutable)) {
+            Move-Item -LiteralPath $backupExecutable -Destination $targetExecutable -Force
+        }
+        throw
+    }
+
+    if (-not $NoPathUpdate) {
+        Add-EtherscanToUserPath -Directory $InstallDir
+    }
+
+    Write-Host ""
+    Write-Host "Etherscan CLI $($resolved.Version) installed successfully."
+    Write-Host "Installed to: $targetExecutable"
+    if ($NoPathUpdate) {
+        Write-Host "Add $InstallDir to PATH to run etherscan from any directory."
+    }
+    else {
+        Write-Host "Run 'etherscan version' to verify the installation."
+        Write-Host "Open a new terminal if the command is not yet available."
+    }
+}
+finally {
+    Remove-Item -LiteralPath $tempDirectory -Recurse -Force -ErrorAction SilentlyContinue
+    if ($CleanupScript -and -not [string]::IsNullOrWhiteSpace($PSCommandPath)) {
+        Remove-Item -LiteralPath $PSCommandPath -Force -ErrorAction SilentlyContinue
+    }
+}

package/scripts/install.sh

@@ -1,211 +1,211 @@
-#!/bin/sh
-
-set -eu
-
-repository="etherscan/etherscan-cli"
-version=${ETHERSCAN_VERSION:-}
-install_dir=${ETHERSCAN_INSTALL_DIR:-"$HOME/.local/bin"}
-download_base=${ETHERSCAN_INSTALL_TEST_DOWNLOAD_BASE_URL:-}
-update_path=1
-
-usage() {
-    cat <<'EOF'
-Install Etherscan CLI.
-
-Usage: install.sh [options]
-
-Options:
-  --version VERSION         Install a specific version (for example, v1.1.0).
-  --install-dir DIRECTORY   Install into DIRECTORY (default: ~/.local/bin).
-  --no-path-update          Do not update the shell profile.
-  -h, --help                Show this help.
-EOF
-}
-
-die() {
-    printf 'error: %s\n' "$*" >&2
-    exit 1
-}
-
-while [ "$#" -gt 0 ]; do
-    case "$1" in
-        --version)
-            [ "$#" -ge 2 ] || die "--version requires a value"
-            version=$2
-            shift 2
-            ;;
-        --install-dir)
-            [ "$#" -ge 2 ] || die "--install-dir requires a value"
-            install_dir=$2
-            shift 2
-            ;;
-        --no-path-update)
-            update_path=0
-            shift
-            ;;
-        -h|--help)
-            usage
-            exit 0
-            ;;
-        *)
-            die "unknown option: $1"
-            ;;
-    esac
-done
-
-if printf '%s' "$install_dir" | LC_ALL=C grep '[[:cntrl:]]' >/dev/null 2>&1; then
-    die "the installation directory cannot contain control characters"
-fi
-
-fetch_stdout() {
-    url=$1
-    if command -v curl >/dev/null 2>&1; then
-        curl -fsSL -A etherscan-cli-installer "$url"
-    elif command -v wget >/dev/null 2>&1; then
-        wget -qO- --user-agent=etherscan-cli-installer "$url"
-    else
-        die "curl or wget is required"
-    fi
-}
-
-fetch_file() {
-    base=$1
-    name=$2
-    destination=$3
-
-    if [ -d "$base" ]; then
-        cp "$base/$name" "$destination"
-        return
-    fi
-
-    case "$base" in
-        file://*)
-            cp "${base#file://}/$name" "$destination"
-            ;;
-        https://*)
-            if command -v curl >/dev/null 2>&1; then
-                curl -fsSL -A etherscan-cli-installer "$base/$name" -o "$destination"
-            elif command -v wget >/dev/null 2>&1; then
-                wget -q --user-agent=etherscan-cli-installer "$base/$name" -O "$destination"
-            else
-                die "curl or wget is required"
-            fi
-            ;;
-        *)
-            die "invalid download base URL or directory: $base"
-            ;;
-    esac
-}
-
-if [ -z "$version" ] || [ "$version" = latest ]; then
-    [ -z "$download_base" ] || die "a version is required with the installer test download source"
-    release_json=$(fetch_stdout "https://api.github.com/repos/$repository/releases/latest")
-    version=$(printf '%s\n' "$release_json" | sed -n 's/.*"tag_name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | sed -n '1p')
-    [ -n "$version" ] || die "could not resolve the latest Etherscan CLI version"
-fi
-
-case "$version" in
-    v*) tag=$version; release_version=${version#v} ;;
-    *) tag="v$version"; release_version=$version ;;
-esac
-
-printf '%s\n' "$tag" | grep -Eq '^v[0-9]+\.[0-9]+\.[0-9]+([-+][0-9A-Za-z.-]+)?$' || die "invalid release version: $tag"
-
-system_name=${ETHERSCAN_INSTALL_TEST_OS:-$(uname -s)}
-case "$system_name" in
-    Linux|linux) os=linux ;;
-    Darwin|darwin) os=darwin ;;
-    *) die "unsupported operating system: $system_name" ;;
-esac
-
-machine_arch=${ETHERSCAN_INSTALL_TEST_ARCH:-$(uname -m)}
-case "$machine_arch" in
-    x86_64|amd64) arch=amd64 ;;
-    arm64|aarch64) arch=arm64 ;;
-    *) die "unsupported architecture: $machine_arch. Etherscan CLI supports amd64 and arm64." ;;
-esac
-
-archive_name="etherscan_${release_version}_${os}_${arch}.tar.gz"
-if [ -z "$download_base" ]; then
-    download_base="https://github.com/$repository/releases/download/$tag"
-fi
-
-temp_dir=$(mktemp -d 2>/dev/null || mktemp -d -t etherscan-install)
-trap 'rm -rf "$temp_dir"' EXIT HUP INT TERM
-archive_path="$temp_dir/$archive_name"
-checksum_path="$temp_dir/checksums.txt"
-source_executable="$temp_dir/etherscan"
-
-printf 'Downloading Etherscan CLI %s for %s/%s...\n' "$release_version" "$os" "$arch"
-fetch_file "$download_base" "$archive_name" "$archive_path"
-fetch_file "$download_base" checksums.txt "$checksum_path"
-
-expected_hash=$(awk -v name="$archive_name" '$2 == name || $2 == ("*" name) { print tolower($1); exit }' "$checksum_path")
-[ -n "$expected_hash" ] || die "no checksum was published for $archive_name"
-printf '%s\n' "$expected_hash" | grep -Eq '^[0-9a-f]{64}$' || die "invalid checksum published for $archive_name"
-
-if command -v sha256sum >/dev/null 2>&1; then
-    actual_hash=$(sha256sum "$archive_path" | awk '{ print tolower($1) }')
-elif command -v shasum >/dev/null 2>&1; then
-    actual_hash=$(shasum -a 256 "$archive_path" | awk '{ print tolower($1) }')
-else
-    die "sha256sum or shasum is required to verify the download"
-fi
-
-[ "$actual_hash" = "$expected_hash" ] || die "checksum verification failed for $archive_name"
-
-entry_count=$(tar -tzf "$archive_path" | awk '$0 == "etherscan" { count++ } END { print count + 0 }')
-[ "$entry_count" -eq 1 ] || die "$archive_name must contain exactly one root-level etherscan"
-tar -xOzf "$archive_path" etherscan >"$source_executable"
-[ -s "$source_executable" ] || die "$archive_name contains an empty etherscan executable"
-
-mkdir -p "$install_dir"
-staged_executable="$install_dir/.etherscan.new.$$"
-cp "$source_executable" "$staged_executable"
-chmod 0755 "$staged_executable"
-mv -f "$staged_executable" "$install_dir/etherscan"
-
-path_updated=0
-if [ "$update_path" -eq 1 ]; then
-    case ":$PATH:" in
-        *:"$install_dir":*) ;;
-        *)
-            shell_name=${SHELL:-sh}
-            shell_name=${shell_name##*/}
-            escaped_install_dir=$(printf '%s' "$install_dir" | sed 's/[\\"$`]/\\&/g')
-            if [ "$shell_name" = fish ]; then
-                profile="$HOME/.config/fish/config.fish"
-                mkdir -p "$(dirname "$profile")"
-                path_line="fish_add_path \"$escaped_install_dir\""
-            else
-                case "$shell_name" in
-                    zsh) profile="$HOME/.zshrc" ;;
-                    bash) profile="$HOME/.bashrc" ;;
-                    *) profile="$HOME/.profile" ;;
-                esac
-                path_line="export PATH=\"$escaped_install_dir:\$PATH\""
-            fi
-
-            # Match the exact line we would write (whole-line, fixed-string) so an
-            # unrelated profile line that merely contains the path does not suppress
-            # the update, and a genuine duplicate is not appended.
-            if ! [ -f "$profile" ] || ! grep -Fx -e "$path_line" "$profile" >/dev/null 2>&1; then
-                {
-                    printf '\n# Etherscan CLI\n'
-                    printf '%s\n' "$path_line"
-                } >>"$profile"
-                path_updated=1
-            fi
-            ;;
-    esac
-fi
-
-printf '\nEtherscan CLI %s installed successfully.\n' "$release_version"
-printf 'Installed to: %s\n' "$install_dir/etherscan"
-if [ "$update_path" -eq 0 ]; then
-    printf 'Add %s to PATH to run etherscan from any directory.\n' "$install_dir"
-elif [ "$path_updated" -eq 1 ]; then
-    printf 'Open a new terminal, then run: etherscan version\n'
-else
-    printf 'Run: etherscan version\n'
-fi
+#!/bin/sh
+
+set -eu
+
+repository="etherscan/etherscan-cli"
+version=${ETHERSCAN_VERSION:-}
+install_dir=${ETHERSCAN_INSTALL_DIR:-"$HOME/.local/bin"}
+download_base=${ETHERSCAN_INSTALL_TEST_DOWNLOAD_BASE_URL:-}
+update_path=1
+
+usage() {
+    cat <<'EOF'
+Install Etherscan CLI.
+
+Usage: install.sh [options]
+
+Options:
+  --version VERSION         Install a specific version (for example, v1.1.0).
+  --install-dir DIRECTORY   Install into DIRECTORY (default: ~/.local/bin).
+  --no-path-update          Do not update the shell profile.
+  -h, --help                Show this help.
+EOF
+}
+
+die() {
+    printf 'error: %s\n' "$*" >&2
+    exit 1
+}
+
+while [ "$#" -gt 0 ]; do
+    case "$1" in
+        --version)
+            [ "$#" -ge 2 ] || die "--version requires a value"
+            version=$2
+            shift 2
+            ;;
+        --install-dir)
+            [ "$#" -ge 2 ] || die "--install-dir requires a value"
+            install_dir=$2
+            shift 2
+            ;;
+        --no-path-update)
+            update_path=0
+            shift
+            ;;
+        -h|--help)
+            usage
+            exit 0
+            ;;
+        *)
+            die "unknown option: $1"
+            ;;
+    esac
+done
+
+if printf '%s' "$install_dir" | LC_ALL=C grep '[[:cntrl:]]' >/dev/null 2>&1; then
+    die "the installation directory cannot contain control characters"
+fi
+
+fetch_stdout() {
+    url=$1
+    if command -v curl >/dev/null 2>&1; then
+        curl -fsSL -A etherscan-cli-installer "$url"
+    elif command -v wget >/dev/null 2>&1; then
+        wget -qO- --user-agent=etherscan-cli-installer "$url"
+    else
+        die "curl or wget is required"
+    fi
+}
+
+fetch_file() {
+    base=$1
+    name=$2
+    destination=$3
+
+    if [ -d "$base" ]; then
+        cp "$base/$name" "$destination"
+        return
+    fi
+
+    case "$base" in
+        file://*)
+            cp "${base#file://}/$name" "$destination"
+            ;;
+        https://*)
+            if command -v curl >/dev/null 2>&1; then
+                curl -fsSL -A etherscan-cli-installer "$base/$name" -o "$destination"
+            elif command -v wget >/dev/null 2>&1; then
+                wget -q --user-agent=etherscan-cli-installer "$base/$name" -O "$destination"
+            else
+                die "curl or wget is required"
+            fi
+            ;;
+        *)
+            die "invalid download base URL or directory: $base"
+            ;;
+    esac
+}
+
+if [ -z "$version" ] || [ "$version" = latest ]; then
+    [ -z "$download_base" ] || die "a version is required with the installer test download source"
+    release_json=$(fetch_stdout "https://api.github.com/repos/$repository/releases/latest")
+    version=$(printf '%s\n' "$release_json" | sed -n 's/.*"tag_name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | sed -n '1p')
+    [ -n "$version" ] || die "could not resolve the latest Etherscan CLI version"
+fi
+
+case "$version" in
+    v*) tag=$version; release_version=${version#v} ;;
+    *) tag="v$version"; release_version=$version ;;
+esac
+
+printf '%s\n' "$tag" | grep -Eq '^v[0-9]+\.[0-9]+\.[0-9]+([-+][0-9A-Za-z.-]+)?$' || die "invalid release version: $tag"
+
+system_name=${ETHERSCAN_INSTALL_TEST_OS:-$(uname -s)}
+case "$system_name" in
+    Linux|linux) os=linux ;;
+    Darwin|darwin) os=darwin ;;
+    *) die "unsupported operating system: $system_name" ;;
+esac
+
+machine_arch=${ETHERSCAN_INSTALL_TEST_ARCH:-$(uname -m)}
+case "$machine_arch" in
+    x86_64|amd64) arch=amd64 ;;
+    arm64|aarch64) arch=arm64 ;;
+    *) die "unsupported architecture: $machine_arch. Etherscan CLI supports amd64 and arm64." ;;
+esac
+
+archive_name="etherscan_${release_version}_${os}_${arch}.tar.gz"
+if [ -z "$download_base" ]; then
+    download_base="https://github.com/$repository/releases/download/$tag"
+fi
+
+temp_dir=$(mktemp -d 2>/dev/null || mktemp -d -t etherscan-install)
+trap 'rm -rf "$temp_dir"' EXIT HUP INT TERM
+archive_path="$temp_dir/$archive_name"
+checksum_path="$temp_dir/checksums.txt"
+source_executable="$temp_dir/etherscan"
+
+printf 'Downloading Etherscan CLI %s for %s/%s...\n' "$release_version" "$os" "$arch"
+fetch_file "$download_base" "$archive_name" "$archive_path"
+fetch_file "$download_base" checksums.txt "$checksum_path"
+
+expected_hash=$(awk -v name="$archive_name" '$2 == name || $2 == ("*" name) { print tolower($1); exit }' "$checksum_path")
+[ -n "$expected_hash" ] || die "no checksum was published for $archive_name"
+printf '%s\n' "$expected_hash" | grep -Eq '^[0-9a-f]{64}$' || die "invalid checksum published for $archive_name"
+
+if command -v sha256sum >/dev/null 2>&1; then
+    actual_hash=$(sha256sum "$archive_path" | awk '{ print tolower($1) }')
+elif command -v shasum >/dev/null 2>&1; then
+    actual_hash=$(shasum -a 256 "$archive_path" | awk '{ print tolower($1) }')
+else
+    die "sha256sum or shasum is required to verify the download"
+fi
+
+[ "$actual_hash" = "$expected_hash" ] || die "checksum verification failed for $archive_name"
+
+entry_count=$(tar -tzf "$archive_path" | awk '$0 == "etherscan" { count++ } END { print count + 0 }')
+[ "$entry_count" -eq 1 ] || die "$archive_name must contain exactly one root-level etherscan"
+tar -xOzf "$archive_path" etherscan >"$source_executable"
+[ -s "$source_executable" ] || die "$archive_name contains an empty etherscan executable"
+
+mkdir -p "$install_dir"
+staged_executable="$install_dir/.etherscan.new.$$"
+cp "$source_executable" "$staged_executable"
+chmod 0755 "$staged_executable"
+mv -f "$staged_executable" "$install_dir/etherscan"
+
+path_updated=0
+if [ "$update_path" -eq 1 ]; then
+    case ":$PATH:" in
+        *:"$install_dir":*) ;;
+        *)
+            shell_name=${SHELL:-sh}
+            shell_name=${shell_name##*/}
+            escaped_install_dir=$(printf '%s' "$install_dir" | sed 's/[\\"$`]/\\&/g')
+            if [ "$shell_name" = fish ]; then
+                profile="$HOME/.config/fish/config.fish"
+                mkdir -p "$(dirname "$profile")"
+                path_line="fish_add_path \"$escaped_install_dir\""
+            else
+                case "$shell_name" in
+                    zsh) profile="$HOME/.zshrc" ;;
+                    bash) profile="$HOME/.bashrc" ;;
+                    *) profile="$HOME/.profile" ;;
+                esac
+                path_line="export PATH=\"$escaped_install_dir:\$PATH\""
+            fi
+
+            # Match the exact line we would write (whole-line, fixed-string) so an
+            # unrelated profile line that merely contains the path does not suppress
+            # the update, and a genuine duplicate is not appended.
+            if ! [ -f "$profile" ] || ! grep -Fx -e "$path_line" "$profile" >/dev/null 2>&1; then
+                {
+                    printf '\n# Etherscan CLI\n'
+                    printf '%s\n' "$path_line"
+                } >>"$profile"
+                path_updated=1
+            fi
+            ;;
+    esac
+fi
+
+printf '\nEtherscan CLI %s installed successfully.\n' "$release_version"
+printf 'Installed to: %s\n' "$install_dir/etherscan"
+if [ "$update_path" -eq 0 ]; then
+    printf 'Add %s to PATH to run etherscan from any directory.\n' "$install_dir"
+elif [ "$path_updated" -eq 1 ]; then
+    printf 'Open a new terminal, then run: etherscan version\n'
+else
+    printf 'Run: etherscan version\n'
+fi