@paimaexample/npm-avail-light-client 0.3.15

package/binary.js

@@ -0,0 +1,173 @@
+const os = require("os");
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+const tar = require("tar");
+const extract = require("extract-zip");
+
+const downloadLinks = {
+  "apple-arm64":
+    "https://github.com/availproject/avail-light/releases/download/avail-light-client-v1.13.0-rc10/avail-light-apple-arm64.tar.gz",
+  "apple-x86_64":
+    "https://github.com/availproject/avail-light/releases/download/avail-light-client-v1.13.0-rc10/avail-light-apple-x86_64.tar.gz",
+  "linux-amd64":
+    "https://github.com/availproject/avail-light/releases/download/avail-light-client-v1.13.0-rc10/avail-light-linux-amd64.tar.gz",
+  "windows-x86_64":
+    "https://github.com/availproject/avail-light/releases/download/avail-light-client-v1.13.0-rc10/avail-light-x86_64-pc-windows-msvc.exe.zip",
+};
+
+const getBinaryKey = () => {
+  const isLinux = os.platform() === "linux";
+  const isWindows = os.platform() === "win32";
+  const isApple = os.platform() === "darwin";
+  const isArm = os.arch() === "arm64";
+  const isX86 = os.arch() === "x64";
+
+  if (isLinux && isArm) {
+    throw new Error(
+      "Unsupported platform: Linux ARM64 is not supported for native binary.",
+    );
+  }
+
+  if (isLinux && isX86) return "linux-amd64";
+
+  if (isWindows && isX86) return "windows-x86_64";
+
+  if (isApple && isArm) return "apple-arm64";
+
+  if (isApple && isX86) return "apple-x86_64";
+
+  throw new Error("Unsupported platform");
+};
+
+const getBinaryLink = () => {
+  const key = getBinaryKey();
+  const binaryLink = downloadLinks[key];
+  if (!binaryLink) throw new Error("Unsupported platform " + key);
+  return binaryLink;
+};
+
+const getBinaryPath = () => {
+  const key = getBinaryKey();
+  const isWindows = key.startsWith("windows");
+  const exeName = isWindows ? "avail-light-client.exe" : "avail-light-client";
+  return path.join(__dirname, "bin", exeName);
+};
+
+const downloadBinary = async () => {
+  const binaryLink = getBinaryLink();
+  const key = getBinaryKey();
+  const binDir = path.join(__dirname, "bin");
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+  }
+
+  const tempPath = path.join(__dirname, path.basename(binaryLink));
+
+  console.log(`Downloading binary from ${binaryLink}...`);
+  const response = await fetch(binaryLink);
+  if (!response.ok) {
+    throw new Error(`Failed to download binary: ${response.statusText}`);
+  }
+  const fileStream = fs.createWriteStream(tempPath);
+  await new Promise(async (resolve, reject) => {
+    try {
+      for await (const chunk of response.body) {
+        fileStream.write(chunk);
+      }
+      fileStream.end();
+      fileStream.on("finish", resolve);
+      fileStream.on("error", reject);
+    } catch (error) {
+      reject(error);
+    }
+  });
+
+  console.log("Extracting binary...");
+  if (binaryLink.endsWith(".zip")) {
+    await extract(tempPath, { dir: path.join(__dirname, "bin") });
+    const files = fs.readdirSync(path.join(__dirname, "bin"));
+    const exeFile = files.find((f) => f.endsWith(".exe"));
+    if (exeFile && exeFile !== "avail-light-client.exe") {
+      fs.renameSync(
+        path.join(__dirname, "bin", exeFile),
+        path.join(__dirname, "bin", "avail-light-client.exe"),
+      );
+    }
+  } else if (binaryLink.endsWith(".tar.gz")) {
+    console.log("Extracting tar.gz file...");
+    console.log(tempPath);
+    console.log(binDir);
+    await tar.x({
+      file: tempPath,
+      cwd: binDir,
+    }).catch((err) => {
+      throw new Error(`Failed to extract tar.gz file: ${err.message}`);
+    });
+
+    // Verify extraction was successful
+    const extractedFiles = fs.readdirSync(binDir);
+    console.log(extractedFiles);
+    if (extractedFiles.length === 0) {
+      throw new Error("No files were extracted from the tar.gz archive");
+    }
+
+    const binaryName = os.platform() === "win32"
+      ? "avail-light-client.exe"
+      : "avail-light-client";
+    if (extractedFiles.length > 0 && extractedFiles[0] !== binaryName) {
+      fs.renameSync(
+        path.join(binDir, extractedFiles[0]),
+        path.join(binDir, binaryName),
+      );
+    }
+
+    // Ensure the binary exists
+    if (!fs.existsSync(path.join(binDir, binaryName))) {
+      throw new Error(
+        `Extracted files do not contain expected binary: ${binaryName}`,
+      );
+    }
+  }
+  console.log("Binary extracted successfully at " + binDir);
+  fs.unlinkSync(tempPath);
+
+  const binaryPath = getBinaryPath();
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(`Binary not found at expected path: ${binaryPath}`);
+  }
+
+  if (os.platform() !== "win32") {
+    fs.chmodSync(binaryPath, "755");
+  }
+
+  console.log("Binary ready at:", binaryPath);
+  return binaryPath;
+};
+
+const runBinary = (args) => {
+  const binaryPath = getBinaryPath();
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(
+      `Binary not found at path: ${binaryPath}. Please run downloadBinary first.`,
+    );
+  }
+  console.log("Running binary at:", binaryPath);
+  console.log("Args:", args);
+  console.log("CWD:", process.cwd());
+  const child = spawn(binaryPath, args, { stdio: "inherit" });
+
+  child.on("exit", (code) => {
+    if (code !== 0) {
+      console.error(`Binary process exited with code ${code}`);
+    }
+  });
+};
+
+module.exports = {
+  getBinaryKey,
+  getBinaryLink,
+  getBinaryPath,
+  downloadBinary,
+  runBinary,
+};

package/config.yml

@@ -0,0 +1,31 @@
+# Default configuration for avail-light-client
+# For a full list of options, see the official Avail documentation.
+
+log_level="info"
+http_server_host="127.0.0.1"
+http_server_port=7007
+
+# Secret key for libp2p keypair. Can be either set to 'seed' or to 'key'.
+# If set to seed, keypair will be generated from that seed.
+# If 'secret_key' is not set, a random seed will be used.
+# secret_key={ seed: "avail" }
+
+# P2P TCP listener port (default: 37000).
+port=37000
+
+# WebSocket endpoint of a full node.
+full_node_ws = ["ws://127.0.0.1:9944"]
+
+# Application ID. If not set or set to 0, application client is not started.
+app_id=0
+
+# Confidence threshold (default: 92.0).
+confidence=92.0
+
+# File system path where RocksDB used by the light client stores its data.
+# This path is relative to the location of this config file.
+avail_path="avail_path"
+
+# Vector of Light Client bootstrap nodes.
+# This is for a local setup. Replace with public bootstraps for testnet/mainnet.
+bootstraps=["/ip4/127.0.0.1/tcp/39000/p2p/12D3KooWMm1c4pzeLPGkkCJMAgFbsfQ8xmVDusg272icWsaNHWzN"] 

package/docker.js

@@ -0,0 +1,79 @@
+const { exec } = require('child_process');
+const util = require('util');
+const path = require('path');
+const fs = require('fs');
+
+const execPromise = util.promisify(exec);
+
+const checkIfDockerExists = async () => {
+    try {
+        await execPromise('docker --version');
+        return true;
+    } catch (error) {
+        return false;
+    }
+};
+
+const runDockerContainer = ({ args = [] }) => {
+    let finalArgs = [...args];
+    let tag = 'availj/avail-light:avail-light-client-v1.13.0-rc11';
+    let p2pPort = 37000;
+    let httpPort = 7007;
+    let volumeMounts = [];
+
+    const extractArgValue = (argName, arr) => {
+        const index = arr.indexOf(argName);
+        if (index > -1 && index < arr.length - 1) {
+            const value = arr[index + 1];
+            arr.splice(index, 2);
+            return value;
+        }
+        return undefined;
+    };
+
+    const customTag = extractArgValue('--docker-tag', finalArgs);
+    if (customTag) tag = customTag;
+
+    const customP2pPort = extractArgValue('--p2p-port', finalArgs);
+    if (customP2pPort) p2pPort = customP2pPort;
+
+    const customHttpPort = extractArgValue('--http-port', finalArgs);
+    if (customHttpPort) httpPort = customHttpPort;
+
+    const configArgIndex = finalArgs.findIndex(arg => arg === '--config');
+    if (configArgIndex === -1) {
+        console.error('FATAL: --config flag with a path is required for Docker execution.');
+        process.exit(1);
+    }
+
+    const hostConfigPath = path.resolve(finalArgs[configArgIndex + 1]);
+    const hostWorkDir = path.dirname(hostConfigPath);
+    const configFileName = path.basename(hostConfigPath);
+    const containerWorkDir = '/data';
+    const containerConfigPath = path.join(containerWorkDir, configFileName);
+
+    volumeMounts.push(`-v "${hostWorkDir}:${containerWorkDir}"`);
+    finalArgs[configArgIndex + 1] = containerConfigPath;
+
+    const portMappings = `-p ${p2pPort}:37000 -p ${httpPort}:7007`;
+
+    const command = `docker run --rm -it ${volumeMounts.join(' ')} ${portMappings} ${tag} ${finalArgs.join(' ')}`;
+
+    console.log(`Executing Docker command: ${command}`);
+    const child = exec(command);
+
+    child.stdout.pipe(process.stdout);
+    child.stderr.pipe(process.stderr);
+
+    child.on('exit', (code) => {
+        if (code !== 0) {
+            console.error(`Docker container exited with code ${code}`);
+        }
+    });
+};
+
+module.exports = {
+    checkIfDockerExists,
+    runDockerContainer,
+};
+

package/identity.toml

@@ -0,0 +1 @@
+avail_secret_uri = 'discover casual enrich injury install chronic useful foot deny brave alter patrol chaos dice essence stomach ski stairs multiply will relief hobby quarter decline'

package/index.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { getBinaryKey, downloadBinary, runBinary, getBinaryPath } = require('./binary');
+const { checkIfDockerExists, runDockerContainer } = require('./docker');
+
+const helpMessage = `
+NAME:
+    avail-light-client - A wrapper for the Avail light client.
+
+DESCRIPTION:
+    A user-friendly npm package that manages and runs the Avail light client command-line tool.
+    It uses a native binary on supported platforms and seamlessly falls back to a Docker container
+    on other operating systems or when explicitly requested.
+
+USAGE:
+    avail-light-client [WRAPPER_OPTIONS] -- [EXECUTABLE_OPTIONS]
+    npx avail-light-client [WRAPPER_OPTIONS] -- [EXECUTABLE_OPTIONS]
+
+WRAPPER OPTIONS:
+    --help, -h          Prints this help message and exits.
+    --docker            Forces the use of Docker, even on a natively supported OS.
+    --docker-tag <TAG>  Specifies a custom Docker image tag to use.
+    --p2p-port <PORT>   Maps a host port to the container's p2p port (37000).
+    --http-port <PORT>  Maps a host port to the container's http port (7007).
+
+EXECUTABLE OPTIONS (passed to the avail-light binary/Docker container):
+    --config <PATH>     Specifies the location of the configuration file.
+                        (Default: The 'config.yml' included with the package)
+    --network <NETWORK> Select a network (e.g., local, turing).
+    --identity <PATH>   Specifies the location of the identity file.
+    --app-id <ID>       The appID for the application client.
+    --verbosity <LEVEL> Sets the log level (e.g., info, debug, trace).
+
+    For a full list of executable flags and options, please refer to the official Avail documentation.
+
+CONFIGURATION:
+    A 'config.yml' file is included with this package. You can use it as a starting point
+    by copying it, modifying it, and then pointing to it with the '--config' option.
+`;
+
+const main = async () => {
+    let args = process.argv.slice(2);
+
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(helpMessage);
+        process.exit(0);
+    }
+
+    const dockerFlagIndex = args.indexOf('--docker');
+    let useDocker = false;
+    if (dockerFlagIndex !== -1) {
+        useDocker = true;
+    }
+
+    let configPath;
+    const configArgIndex = args.findIndex(arg => arg === '--config');
+
+    if (configArgIndex !== -1 && args[configArgIndex + 1]) {
+        configPath = args[configArgIndex + 1];
+    } else {
+        configPath = path.join(__dirname, 'config.yml');
+    }
+
+    const absoluteConfigPath = path.resolve(configPath);
+
+    if (!fs.existsSync(absoluteConfigPath)) {
+        console.error(`Error: Configuration file not found at '${absoluteConfigPath}'`);
+        process.exit(1);
+    }
+    
+    if (configArgIndex !== -1) {
+        args[configArgIndex + 1] = absoluteConfigPath;
+    } else {
+        const dockerArgs = useDocker ? args.filter(arg => !arg.startsWith('--')) : [];
+        args.push('--config', absoluteConfigPath, ...dockerArgs);
+    }
+    
+
+    let isNativeSupported = true;
+    try {
+        getBinaryKey();
+    } catch (e) {
+        isNativeSupported = false;
+    }
+
+    const willUseDocker = useDocker || !isNativeSupported;
+
+    if (willUseDocker) {
+        console.log('Attempting to run with Docker...');
+        const dockerExists = await checkIfDockerExists();
+        if (!dockerExists) {
+            let errorMessage = 'Docker is not installed or the Docker daemon is not running. Please install Docker and try again.';
+            if (!isNativeSupported) {
+                errorMessage = `Your OS is not supported for native binaries, and Docker is not available to use as a fallback. Please install Docker.`;
+            } else if (useDocker) {
+                errorMessage = `You passed the --docker flag, but Docker is not available. Please install Docker or run without the --docker flag.`;
+            }
+            console.error(errorMessage);
+            process.exit(1);
+        }
+        runDockerContainer({ args });
+    } else {
+        const binaryPath = getBinaryPath();
+        try {
+            if (!fs.existsSync(binaryPath)) {
+                console.log('Binary not found, downloading...');
+                await downloadBinary();
+            }
+            const finalArgs = args.filter(arg => arg !== '--docker');
+            runBinary(finalArgs);
+        } catch (error) {
+            console.error('Failed to run native binary:', error.message);
+            console.log('Attempting to fall back to Docker...');
+            const dockerExists = await checkIfDockerExists();
+            if (!dockerExists) {
+                console.error('Failed to run native binary and Docker is not available to use as a fallback. Please install Docker.');
+                process.exit(1);
+            }
+            runDockerContainer({ args });
+        }
+    }
+};
+
+main().catch(error => {
+    console.error(`An unexpected error occurred: ${error.message}`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@paimaexample/npm-avail-light-client",
+  "version": "0.3.15",
+  "description": "A wrapper for the Avail Light Client CLI",
+  "main": "index.js",
+  "bin": {
+    "npm-avail-light-client": "index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "avail",
+    "blockchain"
+  ],
+  "type": "commonjs",
+  "author": "Paima Studios",
+  "license": "ISC",
+  "dependencies": {
+    "extract-zip": "^2.0.1",
+    "tar": "^6.2.0"
+  }
+}