@paimaexample/npm-avail-node 0.3.15

package/binary.js

@@ -0,0 +1,116 @@
+const os = require('os')
+const distro = require('linus')
+const tar = require('tar')
+const fs = require('fs')
+const path = require('path')
+const { spawn } = require('child_process')
+
+const downloadLinks = {
+  'x86_64-ubuntu-2404': 'https://github.com/availproject/avail/releases/download/v2.3.0.1-rc1/x86_64-ubuntu-2404-avail-node.tar.gz',
+  'arm64-ubuntu-2204': 'https://github.com/availproject/avail/releases/download/v2.3.0.1-rc1/arm64-ubuntu-2204-avail-node.tar.gz',
+  'x86_64-ubuntu-2204': 'https://github.com/availproject/avail/releases/download/v2.3.0.1-rc1/x86_64-ubuntu-2204-avail-node.tar.gz',
+  'x86_64-ubuntu-2004': 'https://github.com/availproject/avail/releases/download/v2.3.0.1-rc1/x86_64-ubuntu-2004-avail-node.tar.gz',
+  'x86_64-fedora-41': 'https://github.com/availproject/avail/releases/download/v2.3.0.1-rc1/x86_64-fedora-41-avail-node.tar.gz',
+  'x86_64-arch': 'https://github.com/availproject/avail/releases/download/v2.3.0.1-rc1/x86_64-arch-avail-node.tar.gz',
+  'x86_64-debian-12': 'https://github.com/availproject/avail/releases/download/v2.3.0.1-rc1/x86_64-debian-12-avail-node.tar.gz',
+  'arm64-macos': 'https://paima-midnight.nyc3.cdn.digitaloceanspaces.com/binaries/arm64-macos-avail-node.tar.gz',
+}
+
+const checkIfSupported = () => {
+  const platform = os.platform()
+  const isSupported = platform === 'linux' || platform === 'darwin'
+  if (!isSupported) {
+    console.error('This script is only supported on Linux and macOS.')
+    process.exit(1)
+  }
+  return true
+}
+
+const getBinaryKey = () => {
+  return new Promise((resolve, reject) => {
+    const arch = os.arch() === 'arm64' ? 'arm64' : 'x86_64'
+    if (os.platform() === 'darwin') {
+      if (arch === 'arm64') {
+        return resolve('arm64-macos')
+      }
+      return reject(new Error('Unsupported macos architecture'))
+    }
+    distro.name((err, name) => {
+      if (err) {
+        reject(new Error(`Failed to get distro name: ${err.message}`))
+        return
+      }
+
+      distro.version((err, version) => {
+        if (err) {
+          if (name.toLowerCase() === 'arch') {
+            return resolve(`${arch}-arch`)
+          }
+          reject(new Error(`Failed to get distro version: ${err.message}`))
+          return
+        }
+
+        const distroKey = `${arch}-${name.toLowerCase()}-${version.replace('.', '')}`
+        resolve(distroKey)
+      })
+    })
+  })
+}
+
+const downloadBinary = async (distroKey) => {
+    const link = downloadLinks[distroKey]
+    if (!link) {
+        throw new Error(`Unsupported distro: ${distroKey}`)
+    }
+
+    const binDir = path.join(__dirname, 'bin');
+    if (!fs.existsSync(binDir)) {
+        fs.mkdirSync(binDir, { recursive: true });
+    }
+    
+    console.log(`Downloading from ${link}...`);
+    const response = await fetch(link);
+    if (!response.ok) {
+        throw new Error(`Failed to download binary: ${response.statusText}`);
+    }
+
+    const tarPath = path.join(binDir, 'avail-node.tar.gz');
+    const dest = fs.createWriteStream(tarPath);
+    for await (const chunk of response.body) {
+        dest.write(chunk);
+    }
+    dest.end();
+
+    return new Promise((resolve, reject) => {
+        dest.on('finish', () => {
+            console.log('Extracting binary...');
+            tar.x({
+                file: tarPath,
+                cwd: binDir,
+                strip: 1, 
+            }).then(() => {
+                console.log('Extraction complete.');
+                const binaryPath = path.join(binDir, 'avail-node')
+                fs.chmodSync(binaryPath, '755')
+                fs.unlinkSync(tarPath); 
+                resolve(binaryPath);
+            }).catch(reject);
+        });
+        dest.on('error', reject);
+    });
+}
+
+const runBinary = (binaryPath, args = []) => {
+    const child = spawn(binaryPath, args, { stdio: 'inherit' });
+    child.on('close', (code) => {
+        console.log(`Binary process exited with code ${code}`);
+    });
+}
+
+module.exports = {
+    checkIfSupported,
+    getBinaryKey,
+    downloadBinary,
+    runBinary
+}
+

package/docker.js

@@ -0,0 +1,85 @@
+const { exec } = require('child_process')
+const util = require('util')
+const execAsync = util.promisify(exec)
+const path = require('path')
+const fs = require('fs')
+
+const DOCKER_IMAGE = 'availj/avail'
+
+const dockerPullCommand = (tag='latest') => `docker pull ${DOCKER_IMAGE}:${tag}`
+
+async function checkIfDockerExists() {
+    try {
+        await execAsync('docker --version');
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+const runDockerContainer = (options) => {
+  if (!checkIfDockerExists()) {
+    console.error('Docker is not installed. Please install Docker and try again.')
+    process.exit(1)
+  }
+
+  const {
+    tag = 'latest',
+    p2pPort = 30333,
+    rpcPort = 9944,
+    args = []
+  } = options
+
+  let hostOutputDir = path.join(process.cwd(), 'output')
+  const containerOutputDir = '/output'
+  const finalArgs = []
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg === '-d' || arg === '--base-path') {
+      if (i + 1 < args.length) {
+        hostOutputDir = path.resolve(args[i + 1])
+        i++ // skip next arg, it's the path
+      }
+      continue // Don't add the original -d or --base-path to finalArgs
+    }
+    if (arg.startsWith('--base-path=')) {
+      hostOutputDir = path.resolve(arg.substring('--base-path='.length))
+      continue // Don't add the original --base-path to finalArgs
+    }
+    finalArgs.push(arg)
+  }
+
+  if (!fs.existsSync(hostOutputDir)) {
+    fs.mkdirSync(hostOutputDir, { recursive: true })
+  }
+
+  // Always add the base path for inside the container
+  finalArgs.push('-d', containerOutputDir)
+
+  const command = [
+    'docker run --rm',
+    `-p ${p2pPort}:30333`,
+    `-p ${rpcPort}:9944`,
+    `-v ${hostOutputDir}:${containerOutputDir}`,
+    `${DOCKER_IMAGE}:${tag}`,
+    ...finalArgs
+  ].join(' ')
+
+  console.log(`Running command: ${command}`)
+  const child = exec(command)
+
+  child.stdout.pipe(process.stdout)
+  child.stderr.pipe(process.stderr)
+
+  child.on('close', (code) => {
+    console.log(`Docker container exited with code ${code}`)
+  })
+}
+
+module.exports = {
+    dockerPullCommand,
+    runDockerContainer,
+    checkIfDockerExists
+}
+

package/index.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+const os = require('os')
+const fs = require('fs')
+const path = require('path')
+const { getBinaryKey, downloadBinary, runBinary, checkIfSupported } = require('./binary')
+const { runDockerContainer, checkIfDockerExists } = require('./docker')
+
+const main = async () => {
+
+
+    const rawArgs = process.argv.slice(2)
+    
+    const useDockerFlag = rawArgs.includes('--docker')
+    if (!useDockerFlag && !checkIfSupported()) {
+        console.error('This script is only supported on Linux and macOS.')
+        process.exit(1)
+    }
+    let dockerTag = 'latest'
+    let dockerPort = 30333
+    let dockerPortRpc = 9944
+    const passThroughArgs = []
+
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i]
+        if (arg === '--docker') {
+            continue
+        }
+        if (arg === '--docker-tag') {
+            if (i + 1 < rawArgs.length) {
+                dockerTag = rawArgs[i + 1]
+                i++
+            }
+            continue
+        }
+        if (arg.startsWith('--docker-tag=')) {
+            dockerTag = arg.substring('--docker-tag='.length)
+            continue
+        }
+        if (arg === '--docker-port') {
+            if (i + 1 < rawArgs.length) {
+                dockerPort = rawArgs[i + 1]
+                i++
+            }
+            continue
+        }
+        if (arg.startsWith('--docker-port=')) {
+            dockerPort = arg.substring('--docker-port='.length)
+            continue
+        }
+        if (arg === '--docker-port-rpc') {
+            if (i + 1 < rawArgs.length) {
+                dockerPortRpc = rawArgs[i + 1]
+                i++
+            }
+            continue
+        }
+        if (arg.startsWith('--docker-port-rpc=')) {
+            dockerPortRpc = arg.substring('--docker-port-rpc='.length)
+            continue
+        }
+        passThroughArgs.push(arg)
+    }
+
+    if (useDockerFlag) {
+        const dockerExists = await checkIfDockerExists()
+        if (!dockerExists) {
+            console.error('Error: Docker is required but not found.')
+            console.error('You specified the --docker flag, so Docker is required.')
+            console.error('Please install Docker and ensure the Docker daemon is running.')
+            process.exit(1)
+        }
+    }
+
+    const hasChain = passThroughArgs.some(arg => arg === '--chain' || arg.startsWith('--chain='))
+    const hasDev = passThroughArgs.includes('--dev')
+
+    if (!hasChain && !hasDev) {
+        console.error('Error: The --chain argument is mandatory.')
+        console.error('Please specify a chain (e.g., --chain mainnet) or use the --dev flag for a development environment.')
+        process.exit(1)
+    }
+
+    if (useDockerFlag) {
+        console.log(`Running with Docker (tag: ${dockerTag})...`)
+        runDockerContainer({
+            tag: dockerTag,
+            p2pPort: dockerPort,
+            rpcPort: dockerPortRpc,
+            args: passThroughArgs
+        })
+        return
+    }
+
+    try {
+        console.log('Attempting to use binary...')
+        const binaryKey = await getBinaryKey()
+        if (!binaryKey) {
+            throw new Error('Could not determine binary key for this distribution. Please run with --docker flag.')
+        }
+
+        const binaryDir = path.join(__dirname, 'bin')
+        const binaryPath = path.join(binaryDir, 'avail-node')
+
+        if (!fs.existsSync(binaryPath)) {
+            console.log(`Binary not found for ${binaryKey}, downloading...`)
+            await downloadBinary(binaryKey)
+        } else {
+            console.log('Binary found, skipping download.')
+        }
+
+        runBinary(binaryPath, passThroughArgs)
+    } catch (error) {
+        console.error(`Error: ${error.message}`)
+        console.error('Failed to run binary. Please try running with the --docker flag.')
+        process.exit(1)
+    }
+}
+
+main()

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@paimaexample/npm-avail-node",
+  "version": "0.3.15",
+  "description": "A wrapper for the Avail node binary",
+  "main": "index.js",
+  "bin": {
+    "npm-avail-node": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "linus": "^0.0.6",
+    "tar": "^6.2.0"
+  },
+  "type": "commonjs",
+  "author": "Paima Studios",
+  "license": "ISC"
+}