@alephium/web3 0.0.1-test.0

package/dist/src/utils/bs58.js

@@ -0,0 +1,28 @@
+"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.bs58 = void 0;
+/** This source is under MIT License and come originally from https://github.com/cryptocoinjs/bs58 **/
+const base_x_1 = __importDefault(require("base-x"));
+const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+exports.bs58 = (0, base_x_1.default)(ALPHABET);
+exports.default = exports.bs58;

package/dist/src/utils/djb2.d.ts

@@ -0,0 +1 @@
+export default function djb2(bytes: Uint8Array): number;

package/dist/src/utils/djb2.js

@@ -0,0 +1,27 @@
+"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/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+function djb2(bytes) {
+    let hash = 5381;
+    for (let i = 0; i < bytes.length; i++) {
+        hash = (hash << 5) + hash + (bytes[`${i}`] & 0xff);
+    }
+    return hash;
+}
+exports.default = djb2;

package/dist/src/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './address';
+export * from './bs58';
+export * from './djb2';
+export * from './password-crypto';
+export * from './utils';
+export * from './subscription';

package/dist/src/utils/index.js

@@ -0,0 +1,35 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./address"), exports);
+__exportStar(require("./bs58"), exports);
+__exportStar(require("./djb2"), exports);
+__exportStar(require("./password-crypto"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./subscription"), exports);

package/dist/src/utils/password-crypto.d.ts

@@ -0,0 +1,2 @@
+export declare const encrypt: (password: string, dataRaw: string) => string;
+export declare const decrypt: (password: string, payloadRaw: string) => string;

package/dist/src/utils/password-crypto.js

@@ -0,0 +1,69 @@
+"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/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decrypt = exports.encrypt = void 0;
+const buffer_1 = require("buffer/");
+const crypto_1 = require("crypto");
+const saltByteLength = 64;
+const ivByteLength = 64;
+const authTagLength = 16;
+const encrypt = (password, dataRaw) => {
+    const data = buffer_1.Buffer.from(dataRaw, 'utf8');
+    const salt = (0, crypto_1.randomBytes)(saltByteLength);
+    const derivedKey = keyFromPassword(password, salt);
+    const iv = (0, crypto_1.randomBytes)(ivByteLength);
+    const cipher = createCipher(derivedKey, iv);
+    const encrypted = buffer_1.Buffer.concat([cipher.update(data), cipher.final()]);
+    const authTag = cipher.getAuthTag();
+    const payload = {
+        salt: salt.toString('hex'),
+        iv: iv.toString('hex'),
+        encrypted: buffer_1.Buffer.concat([encrypted, authTag]).toString('hex'),
+        version: 1
+    };
+    return JSON.stringify(payload);
+};
+exports.encrypt = encrypt;
+const decrypt = (password, payloadRaw) => {
+    const payload = JSON.parse(payloadRaw);
+    const version = payload.version;
+    if (version !== 1) {
+        throw new Error(`Invalid version: got ${version}, expected: 1`);
+    }
+    const salt = buffer_1.Buffer.from(payload.salt, 'hex');
+    const iv = buffer_1.Buffer.from(payload.iv, 'hex');
+    const encrypted = buffer_1.Buffer.from(payload.encrypted, 'hex');
+    const derivedKey = keyFromPassword(password, salt);
+    const decipher = createDecipher(derivedKey, iv);
+    const data = encrypted.slice(0, encrypted.length - authTagLength);
+    const authTag = encrypted.slice(encrypted.length - authTagLength, encrypted.length);
+    decipher.setAuthTag(authTag);
+    const decrypted = buffer_1.Buffer.concat([decipher.update(data), decipher.final()]);
+    return decrypted.toString('utf8');
+};
+exports.decrypt = decrypt;
+const createCipher = (key, iv) => {
+    return (0, crypto_1.createCipheriv)('aes-256-gcm', key, iv);
+};
+const createDecipher = (key, iv) => {
+    return (0, crypto_1.createDecipheriv)('aes-256-gcm', key, iv);
+};
+const keyFromPassword = (password, salt) => {
+    return (0, crypto_1.pbkdf2Sync)(password, salt, 10000, 32, 'sha256');
+};

package/dist/src/utils/subscription.d.ts

@@ -0,0 +1,24 @@
+import EventEmitter from 'eventemitter3';
+import { NodeProvider } from '../api';
+declare type MessageCallback<Message> = (message: Message) => Promise<void>;
+declare type ErrorCallback<Message> = (error: any, subscription: Subscription<Message>) => Promise<void>;
+export interface SubscribeOptions<Message> {
+    provider: NodeProvider;
+    pollingInterval: number;
+    messageCallback: MessageCallback<Message>;
+    errorCallback: ErrorCallback<Message>;
+}
+export declare abstract class Subscription<Message> {
+    provider: NodeProvider;
+    pollingInterval: number;
+    protected messageCallback: MessageCallback<Message>;
+    protected errorCallback: ErrorCallback<Message>;
+    protected task: ReturnType<typeof setTimeout> | undefined;
+    protected eventEmitter: EventEmitter;
+    protected cancelled: boolean;
+    constructor(options: SubscribeOptions<Message>);
+    startPolling(): void;
+    unsubscribe(): void;
+    abstract polling(): Promise<void>;
+}
+export {};

package/dist/src/utils/subscription.js

@@ -0,0 +1,52 @@
+"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.Subscription = void 0;
+const eventemitter3_1 = __importDefault(require("eventemitter3"));
+class Subscription {
+    constructor(options) {
+        this.provider = options.provider;
+        this.pollingInterval = options.pollingInterval;
+        this.messageCallback = options.messageCallback;
+        this.errorCallback = options.errorCallback;
+        this.task = undefined;
+        this.cancelled = false;
+        this.eventEmitter = new eventemitter3_1.default();
+    }
+    startPolling() {
+        this.eventEmitter.on('tick', async () => {
+            await this.polling();
+            if (!this.cancelled) {
+                this.task = setTimeout(() => this.eventEmitter.emit('tick'), this.pollingInterval);
+            }
+        });
+        this.eventEmitter.emit('tick');
+    }
+    unsubscribe() {
+        this.eventEmitter.removeAllListeners();
+        this.cancelled = true;
+        if (typeof this.task !== 'undefined') {
+            clearTimeout(this.task);
+        }
+    }
+}
+exports.Subscription = Subscription;

package/dist/src/utils/utils.d.ts

@@ -0,0 +1,30 @@
+import { ec as EC, SignatureInput } from 'elliptic';
+import * as node from '../api/api-alephium';
+import * as explorer from '../api/api-explorer';
+export declare function convertHttpResponse<T>(response: node.HttpResponse<T, {
+    detail: string;
+}> | explorer.HttpResponse<T, {
+    detail: string;
+}>): T;
+export declare function signatureEncode(signature: EC.Signature): string;
+export declare const signatureDecode: (ec: EC, signature: string) => SignatureInput;
+export declare function isHexString(input: string): boolean;
+export declare const groupOfAddress: (address: string) => number;
+export declare function contractIdFromAddress(address: string): Uint8Array;
+export declare function tokenIdFromAddress(address: string): Uint8Array;
+export declare function hexToBinUnsafe(hex: string): Uint8Array;
+export declare function binToHex(bin: Uint8Array): string;
+export declare function publicKeyFromPrivateKey(privateKey: string): string;
+export declare function addressFromPublicKey(publicKey: string): string;
+export declare function addressFromContractId(contractId: string): string;
+export declare function contractIdFromTx(txId: string, outputIndex: number): string;
+export declare function subContractId(parentContractId: string, pathInHex: string): string;
+export declare function stringToHex(str: string): string;
+declare type _Eq<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export declare type Eq<X, Y> = _Eq<{
+    [P in keyof X]: X[P];
+}, {
+    [P in keyof Y]: Y[P];
+}>;
+export declare function assertType<T extends true>(): void;
+export {};

package/dist/src/utils/utils.js

@@ -0,0 +1,199 @@
+"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.assertType = exports.stringToHex = exports.subContractId = exports.contractIdFromTx = exports.addressFromContractId = exports.addressFromPublicKey = exports.publicKeyFromPrivateKey = exports.binToHex = exports.hexToBinUnsafe = exports.tokenIdFromAddress = exports.contractIdFromAddress = exports.groupOfAddress = exports.isHexString = exports.signatureDecode = exports.signatureEncode = exports.convertHttpResponse = void 0;
+const elliptic_1 = require("elliptic");
+const bn_js_1 = __importDefault(require("bn.js"));
+const blakejs_1 = __importDefault(require("blakejs"));
+const bs58_1 = __importDefault(require("./bs58"));
+const buffer_1 = require("buffer/");
+const constants_1 = require("../constants");
+const djb2_1 = __importDefault(require("./djb2"));
+const ec = new elliptic_1.ec('secp256k1');
+function convertHttpResponse(response) {
+    if (response.error) {
+        throw new Error(response.error.detail);
+    }
+    else {
+        return response.data;
+    }
+}
+exports.convertHttpResponse = convertHttpResponse;
+function signatureEncode(signature) {
+    let sNormalized = signature.s;
+    if (ec.n && signature.s.cmp(ec.nh) === 1) {
+        sNormalized = ec.n.sub(signature.s);
+    }
+    const r = signature.r.toString('hex', 66).slice(2);
+    const s = sNormalized.toString('hex', 66).slice(2);
+    return r + s;
+}
+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 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;
+};
+function isHexString(input) {
+    return input.length % 2 === 0 && /[0-9a-f]*$/.test(input);
+}
+exports.isHexString = isHexString;
+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 contractIdFromAddress(address) {
+    return idFromAddress(address);
+}
+exports.contractIdFromAddress = contractIdFromAddress;
+function tokenIdFromAddress(address) {
+    return idFromAddress(address);
+}
+exports.tokenIdFromAddress = tokenIdFromAddress;
+function idFromAddress(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 addressBody;
+    }
+    else {
+        throw new Error(`Invalid contract address type: ${addressType}`);
+    }
+}
+function hexToBinUnsafe(hex) {
+    return buffer_1.Buffer.from(hex, 'hex');
+}
+exports.hexToBinUnsafe = hexToBinUnsafe;
+function binToHex(bin) {
+    return buffer_1.Buffer.from(bin).toString('hex');
+}
+exports.binToHex = binToHex;
+function publicKeyFromPrivateKey(privateKey) {
+    const key = ec.keyFromPrivate(privateKey);
+    return key.getPublic(true, 'hex');
+}
+exports.publicKeyFromPrivateKey = publicKeyFromPrivateKey;
+function addressFromPublicKey(publicKey) {
+    const addressType = buffer_1.Buffer.from([AddressType.P2PKH]);
+    const hash = buffer_1.Buffer.from(blakejs_1.default.blake2b(buffer_1.Buffer.from(publicKey, 'hex'), undefined, 32));
+    const bytes = buffer_1.Buffer.concat([addressType, hash]);
+    return bs58_1.default.encode(bytes);
+}
+exports.addressFromPublicKey = addressFromPublicKey;
+function addressFromContractId(contractId) {
+    const addressType = buffer_1.Buffer.from([AddressType.P2C]);
+    const hash = buffer_1.Buffer.from(hexToBinUnsafe(contractId));
+    const bytes = buffer_1.Buffer.concat([addressType, hash]);
+    return bs58_1.default.encode(bytes);
+}
+exports.addressFromContractId = addressFromContractId;
+function contractIdFromTx(txId, outputIndex) {
+    const txIdBin = hexToBinUnsafe(txId);
+    const data = buffer_1.Buffer.concat([txIdBin, buffer_1.Buffer.from([outputIndex])]);
+    const hash = blakejs_1.default.blake2b(data, undefined, 32);
+    return binToHex(hash);
+}
+exports.contractIdFromTx = contractIdFromTx;
+function subContractId(parentContractId, pathInHex) {
+    const data = buffer_1.Buffer.concat([hexToBinUnsafe(pathInHex), hexToBinUnsafe(parentContractId)]);
+    return binToHex(blakejs_1.default.blake2b(blakejs_1.default.blake2b(data, undefined, 32), undefined, 32));
+}
+exports.subContractId = subContractId;
+function stringToHex(str) {
+    let hex = '';
+    for (let i = 0; i < str.length; i++) {
+        hex += '' + str.charCodeAt(i).toString(16);
+    }
+    return hex;
+}
+exports.stringToHex = stringToHex;
+// eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars
+function assertType() { }
+exports.assertType = assertType;

package/gitignore

@@ -0,0 +1,10 @@
+node_modules/
+dist/
+build/
+web/
+.vscode
+.DS_Store
+coverage/
+/dev/
+!dev/user.conf
+/artifacts/

package/package.json

@@ -0,0 +1,127 @@
+{
+  "name": "@alephium/web3",
+  "version": "0.0.1-test.0",
+  "description": "A JS/TS library to interact with the Alephium platform",
+  "license": "GPL",
+  "main": "dist/src/index.js",
+  "browser": "dist/alephium-web3.min.js",
+  "types": "dist/src/index.d.ts",
+  "exports": {
+    ".": "./dist/src/index.js",
+    "./test": "./dist/src/test/index.js"
+  },
+  "typesVersions": {
+    "*": {
+      "test": [
+        "dist/src/test/"
+      ]
+    }
+  },
+  "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": "token-balance",
+    "explorer_backend_version": "1.7.0"
+  },
+  "scripts": {
+    "build": "rm -rf dist/* && npx tsc --build . && webpack",
+    "bundle": "webpack",
+    "update-schemas": "npm run update-schema:alephium && npm run update-schema:explorer",
+    "update-schema:alephium": "npx swagger-typescript-api -t ./configs -o ./src/api -n api-alephium.ts -p https://raw.githubusercontent.com/alephium/alephium/${npm_package_config_alephium_version}/api/src/main/resources/openapi.json",
+    "update-schema:explorer": "npx swagger-typescript-api -t ./configs -o ./src/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",
+    "test": "jest -i --config ./configs/jest.config.ts",
+    "test:client": "jest -i --config ./configs/jest-client.config.ts",
+    "test:unit": "jest -i --config ./configs/jest-unit.config.ts",
+    "test:watch": "npm run test -- --watch --coverage=false",
+    "test:watch:unit": "npm run test:unit -- --watch --coverage=false",
+    "test:watch:client": "npm run test:client -- --watch --coverage=false",
+    "prepublishOnly": "npm run build",
+    "prepack": "node scripts/rename-gitignore.js .gitignore gitignore",
+    "postpack": "node scripts/rename-gitignore.js gitignore .gitignore",
+    "prettier": "prettier --write \"**/*.{js,jsx,ts,tsx,json,md}\"",
+    "start-devnet": "node scripts/start-devnet.js ${npm_package_config_alephium_version}",
+    "restart-devnet": "npm run start-devnet",
+    "stop-devnet": "node scripts/stop-devnet.js"
+  },
+  "type": "commonjs",
+  "bin": {
+    "alephium": "dist/scripts/create-project.js"
+  },
+  "dependencies": {
+    "base-x": "4.0.0",
+    "blakejs": "1.2.1",
+    "buffer": "^6.0.3",
+    "commander": "^9.1.0",
+    "cross-fetch": "^3.1.5",
+    "crypto-js": "4.1.1",
+    "elliptic": "6.5.4",
+    "eventemitter3": "^4.0.7",
+    "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.5.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",
+    "clean-webpack-plugin": "4.0.0",
+    "crypto-browserify": "^3.12.0",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-header": "^3.1.1",
+    "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-react": "^7.29.4",
+    "eslint-plugin-security": "1.4.0",
+    "html-webpack-plugin": "5.5.0",
+    "jest": "^28.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",
+    "process": "^0.11.10",
+    "react-app-rewired": "^2.2.1",
+    "rewire": "^6.0.0",
+    "shelljs": "^0.8.5",
+    "stream-browserify": "^3.0.0",
+    "swagger-typescript-api": "^9.2.0",
+    "terser-webpack-plugin": "^5.3.1",
+    "ts-jest": "^28.0.2",
+    "ts-node": "^10.7.0",
+    "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"
+  },
+  "prettier": {
+    "printWidth": 120,
+    "tabWidth": 2,
+    "useTabs": false,
+    "semi": false,
+    "singleQuote": true,
+    "bracketSameLine": false,
+    "trailingComma": "none"
+  }
+}

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()