@alephium/web3 0.0.3

package/dist/lib/storage-node.js

@@ -0,0 +1,65 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+class NodeStorage {
+    constructor() {
+        this.remove = (name) => {
+            fs_1.default.unlinkSync(this.walletsUrl + '/' + name + '.dat');
+        };
+        this.load = (name) => {
+            let buffer;
+            try {
+                buffer = fs_1.default.readFileSync(this.walletsUrl + '/' + name + '.dat');
+            }
+            catch (error) {
+                throw new Error(`Unable to load wallet ${name}: ${error}`);
+            }
+            return JSON.parse(buffer.toString());
+        };
+        this.save = (name, json) => {
+            const str = JSON.stringify(json);
+            const data = new Uint8Array(Buffer.from(str));
+            fs_1.default.writeFileSync(this.walletsUrl.toString() + '/' + name + '.dat', data);
+        };
+        this.list = () => {
+            const xs = [];
+            try {
+                const files = fs_1.default.readdirSync(this.walletsUrl);
+                files.forEach(function (file) {
+                    if (file.endsWith('.dat')) {
+                        xs.push(file.substring(0, file.length - 4));
+                    }
+                });
+            }
+            catch (e) {
+                return [];
+            }
+            return xs;
+        };
+        this.walletsUrl = process.env.HOME + '/.alephium-wallet-apps';
+        if (!fs_1.default.existsSync(this.walletsUrl)) {
+            fs_1.default.mkdirSync(this.walletsUrl);
+        }
+    }
+}
+exports.default = NodeStorage;

package/dist/lib/utils.d.ts

@@ -0,0 +1,11 @@
+import * as EC from 'elliptic';
+import NodeStorage from './storage-node';
+import BrowserStorage from './storage-browser';
+export declare const signatureEncode: (ec: EC.ec, signature: EC.ec.Signature) => string;
+export declare const signatureDecode: (ec: EC.ec, signature: string) => {
+    r: string;
+    s: string;
+};
+export declare const getStorage: () => BrowserStorage | NodeStorage;
+export declare const groupOfAddress: (address: string) => number;
+export declare function tokenIdFromAddress(address: string): string;

package/dist/lib/utils.js

@@ -0,0 +1,135 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenIdFromAddress = exports.groupOfAddress = exports.getStorage = exports.signatureDecode = exports.signatureEncode = void 0;
+const bn_js_1 = __importDefault(require("bn.js"));
+const bs58_1 = __importDefault(require("./bs58"));
+const storage_node_1 = __importDefault(require("./storage-node"));
+const storage_browser_1 = __importDefault(require("./storage-browser"));
+const constants_1 = require("./constants");
+const djb2_1 = __importDefault(require("./djb2"));
+const signatureEncode = (ec, signature) => {
+    let sNormalized = signature.s;
+    if (ec.n && signature.s.cmp(ec.nh) === 1) {
+        sNormalized = ec.n.sub(signature.s);
+    }
+    const r = signature.r.toArrayLike(Buffer, 'be', 33).slice(1);
+    const s = sNormalized.toArrayLike(Buffer, 'be', 33).slice(1);
+    const xs = new Uint8Array(r.byteLength + s.byteLength);
+    xs.set(new Uint8Array(r), 0);
+    xs.set(new Uint8Array(s), r.byteLength);
+    return Buffer.from(xs).toString('hex');
+};
+exports.signatureEncode = signatureEncode;
+// the signature should be in hex string format for 64 bytes
+const signatureDecode = (ec, signature) => {
+    if (signature.length !== 128) {
+        throw new Error('Invalid signature length');
+    }
+    const sHex = signature.slice(64, 128);
+    const s = new bn_js_1.default(sHex, 'hex');
+    if (ec.n && s.cmp(ec.nh) < 1) {
+        const decoded = { r: signature.slice(0, 64), s: sHex };
+        return decoded;
+    }
+    else {
+        throw new Error('The signature is not normalized');
+    }
+};
+exports.signatureDecode = signatureDecode;
+const getStorage = () => {
+    const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+    return isBrowser ? new storage_browser_1.default() : new storage_node_1.default();
+};
+exports.getStorage = getStorage;
+const xorByte = (intValue) => {
+    const byte0 = (intValue >> 24) & 0xff;
+    const byte1 = (intValue >> 16) & 0xff;
+    const byte2 = (intValue >> 8) & 0xff;
+    const byte3 = intValue & 0xff;
+    return (byte0 ^ byte1 ^ byte2 ^ byte3) & 0xff;
+};
+var AddressType;
+(function (AddressType) {
+    AddressType[AddressType["P2PKH"] = 0] = "P2PKH";
+    AddressType[AddressType["P2MPKH"] = 1] = "P2MPKH";
+    AddressType[AddressType["P2SH"] = 2] = "P2SH";
+    AddressType[AddressType["P2C"] = 3] = "P2C";
+})(AddressType || (AddressType = {}));
+const groupOfAddress = (address) => {
+    const decoded = bs58_1.default.decode(address);
+    if (decoded.length == 0)
+        throw new Error('Address string is empty');
+    const addressType = decoded[0];
+    const addressBody = decoded.slice(1);
+    if (addressType == AddressType.P2PKH) {
+        return groupOfP2pkhAddress(addressBody);
+    }
+    else if (addressType == AddressType.P2MPKH) {
+        return groupOfP2mpkhAddress(addressBody);
+    }
+    else if (addressType == AddressType.P2SH) {
+        return groupOfP2shAddress(addressBody);
+    }
+    else {
+        throw new Error(`Invalid asset address type: ${addressType}`);
+    }
+};
+exports.groupOfAddress = groupOfAddress;
+const groupOfAddressBytes = (bytes) => {
+    const hint = (0, djb2_1.default)(bytes) | 1;
+    const hash = xorByte(hint);
+    const group = hash % constants_1.TOTAL_NUMBER_OF_GROUPS;
+    return group;
+};
+// Pay to public key hash address
+const groupOfP2pkhAddress = (address) => {
+    if (address.length != 32) {
+        throw new Error(`Invalid p2pkh address length: ${address.length}`);
+    }
+    return groupOfAddressBytes(address);
+};
+// Pay to multiple public key hash address
+const groupOfP2mpkhAddress = (address) => {
+    if ((address.length - 2) % 32 != 0) {
+        throw new Error(`Invalid p2mpkh address length: ${address.length}`);
+    }
+    return groupOfAddressBytes(address.slice(1, 33));
+};
+// Pay to script hash address
+const groupOfP2shAddress = (address) => {
+    return groupOfAddressBytes(address);
+};
+function tokenIdFromAddress(address) {
+    const decoded = bs58_1.default.decode(address);
+    if (decoded.length == 0)
+        throw new Error('Address string is empty');
+    const addressType = decoded[0];
+    const addressBody = decoded.slice(1);
+    if (addressType == AddressType.P2C) {
+        return Buffer.from(addressBody).toString('hex');
+    }
+    else {
+        throw new Error(`Invalid contract address type: ${addressType}`);
+    }
+}
+exports.tokenIdFromAddress = tokenIdFromAddress;

package/dist/lib/wallet.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+declare type WalletProps = {
+    address: string;
+    publicKey: string;
+    privateKey: string;
+    seed: Buffer;
+    mnemonic: string;
+};
+export declare class Wallet {
+    readonly address: string;
+    readonly publicKey: string;
+    readonly privateKey: string;
+    readonly seed: Buffer;
+    readonly mnemonic: string;
+    constructor({ address, publicKey, privateKey, seed, mnemonic }: WalletProps);
+    encrypt: (password: string) => string;
+}
+export declare const getPath: (addressIndex?: number | undefined) => string;
+export declare const getWalletFromMnemonic: (mnemonic: string) => Wallet;
+export declare type AddressAndKeys = {
+    address: string;
+    publicKey: string;
+    privateKey: string;
+    addressIndex: number;
+};
+export declare const deriveNewAddressData: (seed: Buffer, forGroup?: number | undefined, addressIndex?: number | undefined, skipAddressIndexes?: number[]) => AddressAndKeys;
+export declare const walletGenerate: () => Wallet;
+export declare const walletImport: (mnemonic: string) => Wallet;
+export declare const walletOpen: (password: string, encryptedWallet: string) => Wallet;
+export {};

package/dist/lib/wallet.js

@@ -0,0 +1,142 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walletOpen = exports.walletImport = exports.walletGenerate = exports.deriveNewAddressData = exports.getWalletFromMnemonic = exports.getPath = exports.Wallet = void 0;
+const bip32 = __importStar(require("bip32"));
+const bip39 = __importStar(require("bip39"));
+const blakejs_1 = __importDefault(require("blakejs"));
+const bs58_1 = __importDefault(require("./bs58"));
+const password_crypto_1 = require("./password-crypto");
+const constants_1 = require("./constants");
+const address_1 = require("./address");
+class StoredState {
+    constructor({ mnemonic }) {
+        this.version = 1;
+        this.mnemonic = mnemonic;
+    }
+}
+class Wallet {
+    constructor({ address, publicKey, privateKey, seed, mnemonic }) {
+        this.encrypt = (password) => {
+            const storedState = new StoredState({
+                mnemonic: this.mnemonic
+            });
+            return (0, password_crypto_1.encrypt)(password, JSON.stringify(storedState));
+        };
+        this.address = address;
+        this.publicKey = publicKey;
+        this.privateKey = privateKey;
+        this.seed = seed;
+        this.mnemonic = mnemonic;
+    }
+}
+exports.Wallet = Wallet;
+const getPath = (addressIndex) => {
+    if (addressIndex !== undefined &&
+        (addressIndex < 0 || !Number.isInteger(addressIndex) || addressIndex.toString().includes('e'))) {
+        throw new Error('Invalid address index path level');
+    }
+    // Being explicit: we always use coinType 1234 no matter the network.
+    const coinType = "1234'";
+    return `m/44'/${coinType}/0'/0/${addressIndex || '0'}`;
+};
+exports.getPath = getPath;
+const getWalletFromMnemonic = (mnemonic) => {
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    const { address, publicKey, privateKey } = deriveAddressAndKeys(seed);
+    return new Wallet({ seed, address, publicKey, privateKey, mnemonic });
+};
+exports.getWalletFromMnemonic = getWalletFromMnemonic;
+const deriveAddressAndKeys = (seed, addressIndex) => {
+    const masterKey = bip32.fromSeed(seed);
+    const keyPair = masterKey.derivePath((0, exports.getPath)(addressIndex));
+    if (!keyPair.privateKey)
+        throw new Error('Missing private key');
+    const publicKey = keyPair.publicKey.toString('hex');
+    const privateKey = keyPair.privateKey.toString('hex');
+    const hash = blakejs_1.default.blake2b(Buffer.from(publicKey, 'hex'), undefined, 32);
+    const pkhash = Buffer.from(hash);
+    const type = Buffer.from([0]);
+    const bytes = Buffer.concat([type, pkhash]);
+    const address = bs58_1.default.encode(bytes);
+    return { address, publicKey, privateKey, addressIndex: addressIndex || 0 };
+};
+const findNextAvailableAddressIndex = (startIndex, skipIndexes = []) => {
+    let nextAvailableAddressIndex = startIndex;
+    do {
+        nextAvailableAddressIndex++;
+    } while (skipIndexes.includes(nextAvailableAddressIndex));
+    return nextAvailableAddressIndex;
+};
+const deriveNewAddressData = (seed, forGroup, addressIndex, skipAddressIndexes = []) => {
+    if (forGroup !== undefined && (forGroup >= constants_1.TOTAL_NUMBER_OF_GROUPS || forGroup < 0 || !Number.isInteger(forGroup))) {
+        throw new Error('Invalid group number');
+    }
+    const initialAddressIndex = addressIndex || 0;
+    let nextAddressIndex = skipAddressIndexes.includes(initialAddressIndex)
+        ? findNextAvailableAddressIndex(initialAddressIndex, skipAddressIndexes)
+        : initialAddressIndex;
+    let newAddressData = deriveAddressAndKeys(seed, nextAddressIndex);
+    while (forGroup !== undefined && (0, address_1.addressToGroup)(newAddressData.address, constants_1.TOTAL_NUMBER_OF_GROUPS) !== forGroup) {
+        nextAddressIndex = findNextAvailableAddressIndex(newAddressData.addressIndex, skipAddressIndexes);
+        newAddressData = deriveAddressAndKeys(seed, nextAddressIndex);
+    }
+    return newAddressData;
+};
+exports.deriveNewAddressData = deriveNewAddressData;
+const walletGenerate = () => {
+    const mnemonic = bip39.generateMnemonic(256);
+    return (0, exports.getWalletFromMnemonic)(mnemonic);
+};
+exports.walletGenerate = walletGenerate;
+const walletImport = (mnemonic) => {
+    if (!bip39.validateMnemonic(mnemonic)) {
+        throw new Error('Invalid seed phrase');
+    }
+    return (0, exports.getWalletFromMnemonic)(mnemonic);
+};
+exports.walletImport = walletImport;
+const walletOpen = (password, encryptedWallet) => {
+    const dataDecrypted = (0, password_crypto_1.decrypt)(password, encryptedWallet);
+    const config = JSON.parse(dataDecrypted);
+    return (0, exports.getWalletFromMnemonic)(config.mnemonic);
+};
+exports.walletOpen = walletOpen;

package/gitignore

@@ -0,0 +1,9 @@
+node_modules/
+dist/
+.vscode
+.DS_Store
+coverage/
+dev/logs
+dev/network*
+dev/alephium*
+artifacts/

package/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "@alephium/web3",
+  "version": "0.0.3",
+  "description": "A JS/TS library to interact with the Alephium platform",
+  "license": "GPL",
+  "main": "dist/lib/index.js",
+  "browser": "dist/alephium-web3.min.js",
+  "types": "dist/lib/index.d.ts",
+  "exports": {
+    ".": "./dist/lib/index.js",
+    "./api/alephium": "./dist/api/api-alephium.js",
+    "./api/explorer": "./dist/api/api-explorer.js"
+  },
+  "typesVersions": {
+    "*": {
+      "api/alephium": [
+        "dist/api/api-alephium"
+      ],
+      "api/explorer": [
+        "dist/api/api-explorer"
+      ]
+    }
+  },
+  "type": "commonjs",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:alephium/alephium-web3.git"
+  },
+  "homepage": "https://github.com/alephium/alephium-web3",
+  "bugs": {
+    "url": "https://github.com/alephium/alephium-web3/issues"
+  },
+  "author": "Alephium dev <dev@alephium.org>",
+  "config": {
+    "alephium_version": "1.3.0-rc9",
+    "explorer_backend_version": "1.6.0-rc8"
+  },
+  "scripts": {
+    "build": "rm -rf dist && npx tsc --build . && webpack",
+    "update-schemas": "npm run update-schema:alephium && npm run update-schema:explorer",
+    "update-schema:alephium": "npx swagger-typescript-api -t ./api -o ./api -n api-alephium.ts -p https://raw.githubusercontent.com/alephium/alephium/v${npm_package_config_alephium_version}/api/src/main/resources/openapi.json",
+    "update-schema:explorer": "npx swagger-typescript-api -t ./api -o ./api -n api-explorer.ts -p https://raw.githubusercontent.com/alephium/explorer-backend/v${npm_package_config_explorer_backend_version}/app/src/main/resources/explorer-backend-openapi.json",
+    "check-versions": "node scripts/check-versions.js ${npm_package_config_alephium_version} ${npm_package_config_explorer_backend_version}",
+    "dev": "tsnd --respawn lib/index.ts",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --fix --ext .ts",
+    "jest": "jest --useStderr --silent=false --verbose=true --config jestconfig.json",
+    "test": "npm run build && npm run jest",
+    "test:watch": "npm run build && npm run jest -- --watch",
+    "prepublishOnly": "npm run build",
+    "prepack": "node scripts/rename-gitignore.js .gitignore gitignore",
+    "postpack": "node scripts/rename-gitignore.js gitignore .gitignore",
+    "format": "prettier --write \"**/*.{js,jsx,ts,tsx,json,md}\"",
+    "devnet:start": "node scripts/start-devnet.js ${npm_package_config_alephium_version}",
+    "devnet:restart": "npm run devnet:start",
+    "devnet:stop": "node scripts/stop-devnet.js"
+  },
+  "bin": {
+    "alephium": "dist/cli/create-project.js"
+  },
+  "dependencies": {
+    "base-x": "^4.0.0",
+    "bcfg": "~0.1.6",
+    "bip32": "^2.0.6",
+    "bip39": "^3.0.4",
+    "blakejs": "^1.1.1",
+    "chalk": "^4.1.2",
+    "cross-fetch": "^3.1.5",
+    "crypto-js": "^4.1.1",
+    "elliptic": "^6.5.4",
+    "find-up": "^2.1.0",
+    "fs-extra": "^10.0.1"
+  },
+  "devDependencies": {
+    "@types/crypto-js": "^4.1.1",
+    "@types/elliptic": "^6.4.13",
+    "@types/find-up": "^2.1.0",
+    "@types/fs-extra": "^9.0.13",
+    "@types/jest": "^27.0.1",
+    "@types/mock-fs": "^4.13.1",
+    "@types/node": "^16.7.8",
+    "@types/rewire": "^2.5.28",
+    "@typescript-eslint/eslint-plugin": "^4.30.0",
+    "@typescript-eslint/parser": "^4.30.0",
+    "babel-eslint": "^10.1.0",
+    "buffer": "^6.0.3",
+    "crypto-browserify": "^3.12.0",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-header": "^3.1.1",
+    "eslint-plugin-prettier": "^4.0.0",
+    "jest": "^27.1.0",
+    "jest-localstorage-mock": "^2.4.18",
+    "jest-websocket-mock": "^2.2.1",
+    "mock-fs": "^5.1.2",
+    "mock-socket": "^9.0.8",
+    "prettier": "^2.3.2",
+    "rewire": "^6.0.0",
+    "shelljs": "^0.8.5",
+    "stream-browserify": "^3.0.0",
+    "swagger-typescript-api": "^9.2.0",
+    "ts-jest": "^27.0.5",
+    "ts-node": "^10.2.1",
+    "tslib": "^2.3.1",
+    "typescript": "^4.4.2",
+    "webpack": "^5.72.0",
+    "webpack-cli": "^4.9.2"
+  },
+  "engines": {
+    "node": ">=14.0.0",
+    "npm": ">=7.0.0"
+  }
+}

package/scripts/check-versions.js

@@ -0,0 +1,45 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+const fetch = require('cross-fetch')
+const process = require('process')
+
+async function extractNodeVersionFromExplorer(explorerVersion) {
+  const url = `https://raw.githubusercontent.com/alephium/explorer-backend/v${explorerVersion}/project/Dependencies.scala`
+  const response = await (await fetch(url)).text()
+  const regex = /val common = "[^"]+"/
+  const matched = regex.exec(response)[0]
+  return matched.split('"')[1]
+}
+
+async function main() {
+  const nodeVersionConfigured = process.argv[2]
+  const explorerVersionConfigured = process.argv[3]
+  const nodeVersionExpected = await extractNodeVersionFromExplorer(explorerVersionConfigured)
+
+  if (nodeVersionExpected != nodeVersionConfigured) {
+    console.log(
+      `Invalid node version: the configured explorer-backend version (${explorerVersionConfigured}) expects node ${nodeVersionExpected}.`
+    )
+    console.log(`Instead, the configured node version is ${nodeVersionConfigured}`)
+    console.log('Please, check that the configured node and explorer-backend versions in the package.json are correct.')
+    process.exit(1)
+  }
+}
+
+main()

package/scripts/rename-gitignore.js

@@ -0,0 +1,24 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+const { rename } = require('fs')
+
+rename(process.argv[2], process.argv[3], function (error) {
+  if (error) console.log(error)
+  console.log(`Renamed ${process.argv[2]} to ${process.argv[3]}.`)
+})