@etherscan-npm/cli 1.0.2 → 1.0.4

package/README.md

@@ -52,7 +52,7 @@ Or run it once without keeping a global installation:
 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 npm package selects a platform-specific optional dependency containing the native binary. It does not run installation lifecycle scripts. Installing with `--omit=optional` is not supported.
 
 > The package is currently published as `@etherscan-npm/cli` while the `@etherscan` npm scope is being transferred. The `etherscan` command is unchanged.
 
@@ -94,6 +94,30 @@ Ensure your Go binary directory (`GOBIN`, or `GOPATH/bin` by default) is on `PAT
 
 Download the archive for your operating system and architecture plus `checksums.txt` from [GitHub Releases](https://github.com/etherscan/etherscan-cli/releases/latest). Verify the archive's SHA-256 checksum, extract it, and place `etherscan` (or `etherscan.exe`) on your `PATH`.
 
+## Uninstall
+
+Run:
+
+```sh
+etherscan uninstall
+```
+
+The command shows the exact package-manager action or executable and configuration paths before asking for confirmation. Use `--yes` to skip the prompt. Homebrew and npm installations are removed through their owning package manager. Installer, Go, manual, and source builds remove only the exact running executable; custom directories and `PATH` entries are left alone unless the installer recorded that it added them and the directory contains no other files.
+
+The command never requests administrator privileges. If a manually copied binary is in a protected location, it leaves the saved configuration intact and prints the exact command needed to remove the binary. Manually created aliases or separate symlinks may also need to be removed by hand.
+
+The installer scripts can remove a script installation without downloading a release archive:
+
+```sh
+curl -fsSL https://raw.githubusercontent.com/etherscan/etherscan-cli/master/scripts/install.sh | sh -s -- --uninstall
+```
+
+```powershell
+& ([scriptblock]::Create((irm https://raw.githubusercontent.com/etherscan/etherscan-cli/master/scripts/install.ps1))) -Uninstall
+```
+
+Uninstall removes the saved configuration directory. If `ETHERSCAN_API_KEY` is set, unset it separately in the shell or environment where it is defined.
+
 ## Get started
 
 ### 1. Create an API key
@@ -143,7 +167,7 @@ Run `etherscan tui` to open the full-screen endpoint explorer:
 etherscan tui
 ```
 
-The explorer can be opened before authentication and asks you to validate and save a key when you submit an API-backed endpoint. Running `etherscan` with no command prints the Quick Start guide.
+The explorer can be opened before authentication and asks you to validate and save a key when you submit an API-backed endpoint. It is read-only; source and proxy verification submissions remain available through the traditional commands. Running `etherscan` with no command prints the Quick Start guide.
 
 ## Practical workflows
 
@@ -168,6 +192,33 @@ etherscan contract getabi 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
 etherscan contract getsourcecode 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
 ```
 
+### Verify a contract
+
+Verification lives in its own command group, `etherscan contractverification`, so that `etherscan contract` stays purely for reading on-chain contract data. Both groups call the same `contract` API module.
+
+Use `--file` for Solidity, Abstract zkSync-stack, or Vyper source payloads. Stylus verification takes a public Git repository URL instead.
+
+```sh
+# Solidity standard JSON
+etherscan contractverification verify 0xYourContract --file input.json --codeformat solidity-standard-json-input --contractname contracts/Verified.sol:Verified --compilerversion v0.8.24+commit.e11b9ed9
+
+# Abstract uses the zkSync compiler stack (Abstract Mainnet and Sepolia only)
+etherscan --chain abstract contractverification verify-zksync 0xYourContract --file input.json --codeformat solidity-standard-json-input --contractname contracts/Verified.sol:Verified --compilerversion v0.8.24+commit.e11b9ed9 --zksolc-version v1.5.7
+
+# Vyper JSON verification, and Stylus repository verification (Arbitrum One and Sepolia only)
+etherscan contractverification verify-vyper 0xYourContract --file input.json --contractname contracts/Verified.vy:Verified --compilerversion vyper:0.4.0 --optimization-used 0
+etherscan --chain arbitrum contractverification verify-stylus 0xYourContract --source-code https://github.com/example/project --contractname project --compilerversion stylus:0.5.3 --license-type 3
+```
+
+Each submission returns a GUID. Poll it with `check-status` for source verification, or `check-proxy` for a proxy submission:
+
+```sh
+etherscan contractverification check-status <guid>
+etherscan contractverification check-proxy <guid>
+```
+
+Constructor arguments may be supplied as bare ABI-encoded hex or with a `0x` prefix; the CLI sends the documented bare form. Verification source files are limited to 3,000,000 bytes. Run any verification command with `--help` for its exact options.
+
 ### Switch chains
 
 ```sh
@@ -209,7 +260,7 @@ Every command includes built-in parameter and usage help:
 ```sh
 etherscan --help
 etherscan account txlist --help
-etherscan contract verify --help
+etherscan contractverification verify --help
 ```
 
 <details>
@@ -223,7 +274,7 @@ etherscan contract verify --help
 | `etherscan tui` | Launch the interactive explorer |
 | `etherscan login` | Validate and store an API key |
 | `etherscan logout` | Remove the stored API key |
-| `etherscan uninstall` | Remove all CLI configuration |
+| `etherscan uninstall` | Remove the CLI and saved configuration |
 | `etherscan update` | Update a Homebrew or installer-script installation |
 | `etherscan whoami` | Show the active chain and masked API key |
 | `etherscan config` | Get, list, or set CLI configuration |
@@ -264,10 +315,20 @@ etherscan contract verify --help
 | `etherscan contract getabi` | Get a verified contract's ABI | [getabi](https://docs.etherscan.io/api-reference/endpoint/getabi.md) |
 | `etherscan contract getsourcecode` | Get verified source code and contract metadata | [getsourcecode](https://docs.etherscan.io/api-reference/endpoint/getsourcecode.md) |
 | `etherscan contract getcontractcreation` | Get creator and creation transaction data for contracts | [getcontractcreation](https://docs.etherscan.io/api-reference/endpoint/getcontractcreation.md) |
-| `etherscan contract verify` | Submit contract source code for verification | [verifysourcecode](https://docs.etherscan.io/api-reference/endpoint/verifysourcecode.md) |
-| `etherscan contract verify-status` | Check a source verification submission | [checkverifystatus](https://docs.etherscan.io/api-reference/endpoint/checkverifystatus.md) |
-| `etherscan contract verify-proxy` | Submit a proxy contract for verification | [verifyproxycontract](https://docs.etherscan.io/api-reference/endpoint/verifyproxycontract.md) |
-| `etherscan contract check-proxy` | Check a proxy verification submission | [checkproxyverification](https://docs.etherscan.io/api-reference/endpoint/checkproxyverification.md) |
+
+### Contract verification
+
+Grouped separately from the contract data commands above. All of these call the `contract` API module.
+
+| Command | Description | API docs |
+| --- | --- | --- |
+| `etherscan contractverification verify` | Submit Solidity source code for verification | [verifysourcecode](https://docs.etherscan.io/api-reference/endpoint/verifysourcecode.md) |
+| `etherscan contractverification verify-zksync` | Submit zkSync-stack source code on Abstract | [verifyzksyncsourcecode](https://docs.etherscan.io/api-reference/endpoint/verifyzksyncsourcecode.md) |
+| `etherscan contractverification verify-vyper` | Submit Vyper source code for verification | [verifyvyper](https://docs.etherscan.io/api-reference/endpoint/verifyvyper.md) |
+| `etherscan contractverification verify-stylus` | Submit Stylus source code for verification | [verifystylus](https://docs.etherscan.io/api-reference/endpoint/verifystylus.md) |
+| `etherscan contractverification verify-proxy` | Submit a proxy contract for verification | [verifyproxycontract](https://docs.etherscan.io/api-reference/endpoint/verifyproxycontract.md) |
+| `etherscan contractverification check-status` | Check a source verification submission | [checkverifystatus](https://docs.etherscan.io/api-reference/endpoint/checkverifystatus.md) |
+| `etherscan contractverification check-proxy` | Check a proxy verification submission | [checkproxyverification](https://docs.etherscan.io/api-reference/endpoint/checkproxyverification.md) |
 
 ### Transaction
 
@@ -427,9 +488,20 @@ go build -o etherscan ./cmd/etherscan
 
 Installer changes can be checked with `sh scripts/test-install.sh` on macOS/Linux or `./scripts/test-install.ps1` in PowerShell on Windows.
 
-The npm distribution can be checked with `sh scripts/test-npm.sh` on macOS/Linux or `./scripts/test-npm.ps1` in PowerShell. These tests pack and install the package against local fixture release archives; they do not publish to npm.
+The npm distribution can be checked with `sh scripts/test-npm.sh` on macOS/Linux or `./scripts/test-npm.ps1` in PowerShell. These tests pack and install the umbrella and current-platform packages with lifecycle scripts disabled; they do not publish to npm.
+
+The first seven-package npm release requires a one-time bootstrap by an npm administrator with publish access to the `@etherscan-npm` scope. After the matching GitHub release succeeds, check out its exact tag and run:
+
+```sh
+gh release download v1.0.4 --dir dist
+npm login
+npm whoami
+VERSION=1.0.4 node npm/publish.js
+```
+
+The publisher verifies all six archives against `checksums.txt`, creates the six public platform packages by publishing them first, and publishes `@etherscan-npm/cli` last. It safely skips exact versions that already exist so a partial publication can be retried. Replace `1.0.4` with the actual unused release version if necessary.
 
-For the first npm release, publish the GitHub release assets before publishing the package. From an exact release-tag checkout, run `npm version --no-git-tag-version <version>` followed by `npm publish --access public`. Then configure npm trusted publishing for `etherscan/etherscan-cli` and `.github/workflows/release.yml`, and set the `NPM_PUBLISH_ENABLED` repository variable to `true` for later tagged releases.
+After the bootstrap, configure npm trusted publishing for the umbrella and all six platform packages, targeting `etherscan/etherscan-cli` and `.github/workflows/release.yml`. Set the `NPM_PUBLISH_ENABLED` repository variable to `true`; subsequent tagged releases publish through GitHub Actions with provenance.
 
 ## API coverage and support
 

package/npm/bin/etherscan.js

@@ -3,21 +3,45 @@
 "use strict";
 
 const fs = require("node:fs");
+const os = require("node:os");
 const path = require("node:path");
 const { spawnSync } = require("node:child_process");
+const packageInfo = require("../../package.json");
+const { PLATFORMS, platformPackage } = require("../platform");
 
 const packageRoot = path.resolve(__dirname, "..", "..");
-const executable = path.join(
-  packageRoot,
-  "vendor",
-  process.platform === "win32" ? "etherscan.exe" : "etherscan",
-);
+
+// Resolve these once so the package lookup and executable name cannot disagree.
+const platform = os.platform();
+const arch = os.arch();
+const binaryName = platform === "win32" ? "etherscan.exe" : "etherscan";
+const reinstallHint = `Reinstall ${packageInfo.name} without --omit=optional.`;
+
+function getExecutable() {
+  const packageName = platformPackage(platform, arch);
+  if (!packageName) {
+    console.error(
+      `Etherscan CLI does not support ${platform} ${arch}. ` +
+        `Supported platforms: ${Object.keys(PLATFORMS).join(", ")}.`,
+    );
+    process.exit(1);
+  }
+
+  try {
+    const manifest = require.resolve(`${packageName}/package.json`, {
+      paths: [packageRoot],
+    });
+    return path.join(path.dirname(manifest), binaryName);
+  } catch {
+    console.error(`The platform package ${packageName} is not installed. ${reinstallHint}`);
+    process.exit(1);
+  }
+}
+
+const executable = getExecutable();
 
 if (!fs.existsSync(executable)) {
-  console.error(
-    "Etherscan CLI is not installed in this npm package. " +
-      "Reinstall @etherscan-npm/cli without --ignore-scripts.",
-  );
+  console.error(`The platform package executable is missing: ${executable}. ${reinstallHint}`);
   process.exit(1);
 }
 
@@ -26,6 +50,8 @@ const result = spawnSync(executable, process.argv.slice(2), {
   env: {
     ...process.env,
     ETHERSCAN_INSTALL_METHOD: "npm",
+    ETHERSCAN_NPM_PACKAGE: packageInfo.name,
+    ETHERSCAN_NPM_WRAPPER_PID: String(process.pid),
   },
 });
 

package/npm/platform.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const PLATFORMS = Object.freeze({
+  "darwin arm64": "@etherscan-npm/cli-darwin-arm64",
+  "darwin x64": "@etherscan-npm/cli-darwin-x64",
+  "linux arm64": "@etherscan-npm/cli-linux-arm64",
+  "linux x64": "@etherscan-npm/cli-linux-x64",
+  "win32 arm64": "@etherscan-npm/cli-win32-arm64",
+  "win32 x64": "@etherscan-npm/cli-win32-x64",
+});
+
+function platformPackage(platform, arch) {
+  return PLATFORMS[`${platform} ${arch}`] || null;
+}
+
+module.exports = { PLATFORMS, platformPackage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etherscan-npm/cli",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Command-line client and interactive explorer for the Etherscan V2 API",
   "license": "MIT",
   "homepage": "https://github.com/etherscan/etherscan-cli",
@@ -16,7 +16,6 @@
     "etherscan": "npm/bin/etherscan.js"
   },
   "scripts": {
-    "postinstall": "node npm/postinstall.js",
     "prepublishOnly": "node npm/prepublish-check.js",
     "test:package": "npm pack --dry-run",
     "test:release": "node npm/publish.test.js",
@@ -24,13 +23,18 @@
   },
   "files": [
     "npm/bin/etherscan.js",
-    "npm/postinstall.js",
-    "npm/prepublish-check.js",
-    "scripts/install.sh",
-    "scripts/install.ps1",
+    "npm/platform.js",
     "README.md",
     "LICENSE"
   ],
+  "optionalDependencies": {
+    "@etherscan-npm/cli-darwin-arm64": "1.0.4",
+    "@etherscan-npm/cli-darwin-x64": "1.0.4",
+    "@etherscan-npm/cli-linux-arm64": "1.0.4",
+    "@etherscan-npm/cli-linux-x64": "1.0.4",
+    "@etherscan-npm/cli-win32-arm64": "1.0.4",
+    "@etherscan-npm/cli-win32-x64": "1.0.4"
+  },
   "engines": {
     "node": ">=18"
   },

package/npm/postinstall.js

@@ -1,58 +0,0 @@
-"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,81 +0,0 @@
-"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/scripts/install.ps1

@@ -1,262 +0,0 @@
-[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 +0,0 @@
-#!/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