@alephium/web3 0.2.0-rc.8 → 0.2.0-test.1

package/dist/src/contract/contract.js

@@ -18,11 +18,7 @@ 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;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
+    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];
@@ -43,9 +39,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toApiVal = exports.extractArray = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = void 0;
+exports.toApiVal = exports.extractArray = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = void 0;
 const buffer_1 = require("buffer/");
-const crypto_1 = require("crypto");
+const cryptojs = __importStar(require("crypto-js"));
+const crypto = __importStar(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
 const fs_2 = require("fs");
 const ralph = __importStar(require("./ralph"));
@@ -58,39 +55,35 @@ var SourceType;
     SourceType[SourceType["AbstractContract"] = 2] = "AbstractContract";
     SourceType[SourceType["Interface"] = 3] = "Interface";
 })(SourceType || (SourceType = {}));
-exports.DEFAULT_NODE_COMPILER_OPTIONS = {
-    ignoreUnusedConstantsWarnings: false,
-    ignoreUnusedVariablesWarnings: false,
-    ignoreUnusedFieldsWarnings: false,
-    ignoreUnusedPrivateFunctionsWarnings: false,
-    ignoreReadonlyCheckWarnings: false,
-    ignoreExternalCallCheckWarnings: false
+exports.DEFAULT_COMPILER_OPTIONS = {
+    errorOnWarnings: true,
+    ignoreUnusedConstantsWarnings: true
 };
-exports.DEFAULT_COMPILER_OPTIONS = { errorOnWarnings: true, ...exports.DEFAULT_NODE_COMPILER_OPTIONS };
 class TypedMatcher {
     constructor(pattern, type) {
         this.matcher = new RegExp(pattern, 'mg');
         this.type = type;
+        this.name = undefined;
     }
     match(str) {
-        const results = str.match(this.matcher);
-        return results === null ? 0 : results.length;
+        const results = [...str.matchAll(this.matcher)];
+        if (results.length > 0) {
+            this.name = results[0][1];
+        }
+        return results.length;
     }
 }
 class SourceFile {
-    constructor(type, sourceCode, sourceCodeHash, contractPath) {
+    constructor(type, typeId, sourceCode, contractPath) {
         this.type = type;
+        this.typeId = typeId;
         this.sourceCode = sourceCode;
-        this.sourceCodeHash = sourceCodeHash;
+        this.sourceCodeHash = cryptojs.SHA256(sourceCode).toString();
         this.contractPath = contractPath;
     }
     getArtifactPath(artifactsRootPath) {
         return artifactsRootPath + this.contractPath.slice(this.contractPath.indexOf('/')) + '.json';
     }
-    static async from(type, sourceCode, contractPath) {
-        const sourceCodeHash = await crypto_1.webcrypto.subtle.digest('SHA-256', buffer_1.Buffer.from(sourceCode));
-        return new SourceFile(type, sourceCode, buffer_1.Buffer.from(sourceCodeHash).toString('hex'), contractPath);
-    }
 }
 class Compiled {
     constructor(sourceFile, artifact, warnings) {
@@ -100,35 +93,15 @@ class Compiled {
     }
 }
 class ProjectArtifact {
-    constructor(compilerOptionsUsed, infos) {
-        ProjectArtifact.checkCompilerOptionsParameter(compilerOptionsUsed);
-        this.compilerOptionsUsed = compilerOptionsUsed;
+    constructor(infos) {
         this.infos = infos;
     }
-    static checkCompilerOptionsParameter(compilerOptions) {
-        if (Object.keys(compilerOptions).length != Object.keys(exports.DEFAULT_NODE_COMPILER_OPTIONS).length) {
-            throw Error(`Not all compiler options are set: ${compilerOptions}`);
-        }
-        const combined = { ...compilerOptions, ...exports.DEFAULT_NODE_COMPILER_OPTIONS };
-        if (Object.keys(combined).length !== Object.keys(exports.DEFAULT_NODE_COMPILER_OPTIONS).length) {
-            throw Error(`There are unknown compiler options: ${compilerOptions}`);
-        }
-    }
     async saveToFile(rootPath) {
         const filepath = rootPath + '/' + ProjectArtifact.artifactFileName;
-        const artifact = { compilerOptionsUsed: this.compilerOptionsUsed, infos: Object.fromEntries(this.infos) };
-        const content = JSON.stringify(artifact, null, 2);
+        const content = JSON.stringify(Object.fromEntries(this.infos), null, 2);
         return fs_2.promises.writeFile(filepath, content);
     }
-    needToReCompile(compilerOptions, files) {
-        ProjectArtifact.checkCompilerOptionsParameter(compilerOptions);
-        const optionsMatched = Object.entries(compilerOptions).every(([key, inputOption]) => {
-            const usedOption = this.compilerOptionsUsed[`${key}`];
-            return usedOption === inputOption;
-        });
-        if (!optionsMatched) {
-            return true;
-        }
+    sourceHasChanged(files) {
         if (files.length !== this.infos.size) {
             return true;
         }
@@ -146,48 +119,19 @@ class ProjectArtifact {
             return undefined;
         }
         const content = await fs_2.promises.readFile(filepath);
-        const json = JSON.parse(content.toString());
-        const compilerOptionsUsed = json.compilerOptionsUsed;
-        const files = new Map(Object.entries(json.infos));
-        return new ProjectArtifact(compilerOptionsUsed, files);
+        const files = new Map(Object.entries(JSON.parse(content.toString())));
+        return new ProjectArtifact(files);
     }
 }
 ProjectArtifact.artifactFileName = '.project.json';
 class Project {
-    constructor(provider, contractsRootPath, artifactsRootPath, sourceFiles, contracts, scripts, errorOnWarnings, projectArtifact) {
+    constructor(provider, contractsRootPath, artifactsRootPath, sourceFiles, contracts, scripts) {
         this.nodeProvider = provider;
         this.contractsRootPath = contractsRootPath;
         this.artifactsRootPath = artifactsRootPath;
         this.sourceFiles = sourceFiles;
         this.contracts = contracts;
         this.scripts = scripts;
-        this.projectArtifact = projectArtifact;
-        if (errorOnWarnings) {
-            Project.checkCompilerWarnings([...contracts.map((c) => c.warnings).flat(), ...scripts.map((s) => s.warnings).flat()], errorOnWarnings);
-        }
-    }
-    static buildProjectArtifact(sourceFiles, contracts, scripts, compilerOptions) {
-        const files = new Map();
-        contracts.forEach((c) => {
-            files.set(c.sourceFile.contractPath, {
-                sourceCodeHash: c.sourceFile.sourceCodeHash,
-                warnings: c.warnings
-            });
-        });
-        scripts.forEach((s) => {
-            files.set(s.sourceFile.contractPath, {
-                sourceCodeHash: s.sourceFile.sourceCodeHash,
-                warnings: s.warnings
-            });
-        });
-        const compiledSize = contracts.length + scripts.length;
-        sourceFiles.slice(compiledSize).forEach((c) => {
-            files.set(c.contractPath, {
-                sourceCodeHash: c.sourceCodeHash,
-                warnings: []
-            });
-        });
-        return new ProjectArtifact(compilerOptions, files);
     }
     getContractPath(path) {
         return path.startsWith(`./${this.contractsRootPath}`)
@@ -196,12 +140,15 @@ class Project {
                 ? path
                 : this.contractsRootPath + '/' + path;
     }
-    static checkCompilerWarnings(warnings, errorOnWarnings) {
-        if (warnings.length !== 0) {
+    static checkCompilerWarnings(warnings, compilerOptions) {
+        const remains = compilerOptions.ignoreUnusedConstantsWarnings
+            ? warnings.filter((s) => !s.includes('unused constants'))
+            : warnings;
+        if (remains.length !== 0) {
             const prefixPerWarning = '  - ';
-            const warningString = prefixPerWarning + warnings.join('\n' + prefixPerWarning);
-            const output = `Compilation warnings:\n` + warningString + '\n';
-            if (errorOnWarnings) {
+            const warningString = prefixPerWarning + remains.join('\n' + prefixPerWarning);
+            const output = 'Compilation warnings:\n' + warningString + '\n';
+            if (compilerOptions.errorOnWarnings) {
                 throw new Error(output);
             }
             else {
@@ -209,20 +156,22 @@ class Project {
             }
         }
     }
-    static contract(path) {
+    static contract(path, compilerOptions) {
         const contractPath = Project.currentProject.getContractPath(path);
         const contract = Project.currentProject.contracts.find((c) => c.sourceFile.contractPath === contractPath);
         if (typeof contract === 'undefined') {
             throw new Error(`Contract ${contractPath} does not exist`);
         }
+        Project.checkCompilerWarnings(contract.warnings, { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptions });
         return contract.artifact;
     }
-    static script(path) {
+    static script(path, compilerOptions) {
         const contractPath = Project.currentProject.getContractPath(path);
         const script = Project.currentProject.scripts.find((c) => c.sourceFile.contractPath === contractPath);
         if (typeof script === 'undefined') {
             throw new Error(`Script ${contractPath} does not exist`);
         }
+        Project.checkCompilerWarnings(script.warnings, { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptions });
         return script.artifact;
     }
     async saveArtifactsToFile() {
@@ -241,7 +190,6 @@ class Project {
         for (const script of this.scripts) {
             await saveToFile(script);
         }
-        await this.projectArtifact.saveToFile(this.artifactsRootPath);
     }
     contractByCodeHash(codeHash) {
         const contract = this.contracts.find((c) => c.artifact.codeHash === codeHash);
@@ -250,30 +198,53 @@ class Project {
         }
         return contract.artifact;
     }
-    static async compile(provider, files, contractsRootPath, artifactsRootPath, errorOnWarnings, compilerOptions) {
+    async saveProjectArtifactToFile() {
+        const files = new Map();
+        this.contracts.forEach((c) => {
+            files.set(c.sourceFile.contractPath, {
+                sourceCodeHash: c.sourceFile.sourceCodeHash,
+                warnings: c.warnings
+            });
+        });
+        this.scripts.forEach((s) => {
+            files.set(s.sourceFile.contractPath, {
+                sourceCodeHash: s.sourceFile.sourceCodeHash,
+                warnings: s.warnings
+            });
+        });
+        const compiledSize = this.contracts.length + this.scripts.length;
+        this.sourceFiles.slice(compiledSize).forEach((c) => {
+            files.set(c.contractPath, {
+                sourceCodeHash: c.sourceCodeHash,
+                warnings: []
+            });
+        });
+        const projectArtifact = new ProjectArtifact(files);
+        await projectArtifact.saveToFile(this.artifactsRootPath);
+    }
+    static async compile(provider, files, contractsRootPath, artifactsRootPath) {
         const sourceStr = files.map((f) => f.sourceCode).join('\n');
         const result = await provider.contracts.postContractsCompileProject({
-            code: sourceStr,
-            compilerOptions: compilerOptions
+            code: sourceStr
         });
         const contracts = [];
         const scripts = [];
         result.contracts.forEach((contractResult, index) => {
             const sourceFile = files[`${index}`];
-            const contract = Contract.fromCompileResult(contractResult);
+            const contract = Contract.fromCompileResult(sourceFile.typeId, contractResult);
             contracts.push(new Compiled(sourceFile, contract, contractResult.warnings));
         });
         result.scripts.forEach((scriptResult, index) => {
             const sourceFile = files[index + contracts.length];
-            const script = Script.fromCompileResult(scriptResult);
+            const script = Script.fromCompileResult(sourceFile.typeId, scriptResult);
             scripts.push(new Compiled(sourceFile, script, scriptResult.warnings));
         });
-        const projectArtifact = Project.buildProjectArtifact(files, contracts, scripts, compilerOptions);
-        const project = new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts, errorOnWarnings, projectArtifact);
+        const project = new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts);
         await project.saveArtifactsToFile();
+        await project.saveProjectArtifactToFile();
         return project;
     }
-    static async loadArtifacts(provider, files, projectArtifact, contractsRootPath, artifactsRootPath, errorOnWarnings, compilerOptions) {
+    static async loadArtifacts(provider, files, projectArtifact, contractsRootPath, artifactsRootPath) {
         try {
             const contracts = [];
             const scripts = [];
@@ -293,11 +264,11 @@ class Project {
                     scripts.push(new Compiled(file, artifact, warnings));
                 }
             }
-            return new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts, errorOnWarnings, projectArtifact);
+            return new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts);
         }
         catch (error) {
             console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`);
-            return Project.compile(provider, files, contractsRootPath, artifactsRootPath, errorOnWarnings, compilerOptions);
+            return Project.compile(provider, files, contractsRootPath, artifactsRootPath);
         }
     }
     static async loadSourceFile(dirPath, filename) {
@@ -316,8 +287,12 @@ class Project {
             throw new Error(`Multiple definitions in file: ${contractPath}`);
         }
         const matcherIndex = results.indexOf(1);
-        const type = this.matchers[`${matcherIndex}`].type;
-        return SourceFile.from(type, sourceStr, contractPath);
+        const matcher = this.matchers[`${matcherIndex}`];
+        const type = matcher.type;
+        if (matcher.name === undefined) {
+            throw new Error(`Invalid definition in file: ${contractPath}`);
+        }
+        return new SourceFile(type, matcher.name, sourceStr, contractPath);
     }
     static async loadSourceFiles(contractsRootPath) {
         const loadDir = async function (dirPath, results) {
@@ -341,26 +316,23 @@ class Project {
         }
         return sourceFiles.sort((a, b) => a.type - b.type);
     }
-    static async build(compilerOptionsPartial = {}, contractsRootPath = 'contracts', artifactsRootPath = 'artifacts') {
+    static async build(contractsRootPath = 'contracts', artifactsRootPath = 'artifacts') {
         const provider = (0, global_1.getCurrentNodeProvider)();
         const sourceFiles = await Project.loadSourceFiles(contractsRootPath);
-        const { errorOnWarnings, ...nodeCompilerOptions } = { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial };
         const projectArtifact = await ProjectArtifact.from(artifactsRootPath);
-        if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {
-            console.log(`Compile contracts in folder "${contractsRootPath}"`);
-            Project.currentProject = await Project.compile(provider, sourceFiles, contractsRootPath, artifactsRootPath, errorOnWarnings, nodeCompilerOptions);
+        if (typeof projectArtifact === 'undefined' || projectArtifact.sourceHasChanged(sourceFiles)) {
+            Project.currentProject = await Project.compile(provider, sourceFiles, contractsRootPath, artifactsRootPath);
         }
         else {
-            console.log(`Load compiled contracts from folder "${artifactsRootPath}"`);
-            Project.currentProject = await Project.loadArtifacts(provider, sourceFiles, projectArtifact, contractsRootPath, artifactsRootPath, errorOnWarnings, nodeCompilerOptions);
+            Project.currentProject = await Project.loadArtifacts(provider, sourceFiles, projectArtifact, contractsRootPath, artifactsRootPath);
         }
     }
 }
 exports.Project = Project;
-Project.abstractContractMatcher = new TypedMatcher('^Abstract Contract [A-Z][a-zA-Z0-9]*', SourceType.AbstractContract);
-Project.contractMatcher = new TypedMatcher('^Contract [A-Z][a-zA-Z0-9]*', SourceType.Contract);
-Project.interfaceMatcher = new TypedMatcher('^Interface [A-Z][a-zA-Z0-9]* \\{', SourceType.Interface);
-Project.scriptMatcher = new TypedMatcher('^TxScript [A-Z][a-zA-Z0-9]*', SourceType.Script);
+Project.abstractContractMatcher = new TypedMatcher('^Abstract Contract ([A-Z][a-zA-Z0-9]*)\\(*', SourceType.AbstractContract);
+Project.contractMatcher = new TypedMatcher('^Contract ([A-Z][a-zA-Z0-9]*)\\(*', SourceType.Contract);
+Project.interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*) \\{', SourceType.Interface);
+Project.scriptMatcher = new TypedMatcher('^TxScript ([A-Z][a-zA-Z0-9]*)( \\{*|\\(*)', SourceType.Script);
 Project.matchers = [
     Project.abstractContractMatcher,
     Project.contractMatcher,
@@ -368,7 +340,8 @@ Project.matchers = [
     Project.scriptMatcher
 ];
 class Artifact {
-    constructor(functions) {
+    constructor(typeId, functions) {
+        this.typeId = typeId;
         this.functions = functions;
     }
     publicFunctions() {
@@ -383,8 +356,8 @@ class Artifact {
 }
 exports.Artifact = Artifact;
 class Contract extends Artifact {
-    constructor(bytecode, codeHash, fieldsSig, eventsSig, functions) {
-        super(functions);
+    constructor(typeId, bytecode, codeHash, fieldsSig, eventsSig, functions) {
+        super(typeId, functions);
         this.bytecode = bytecode;
         this.codeHash = codeHash;
         this.fieldsSig = fieldsSig;
@@ -399,11 +372,11 @@ class Contract extends Artifact {
             artifact.functions == null) {
             throw Error('The artifact JSON for contract is incomplete');
         }
-        const contract = new Contract(artifact.bytecode, artifact.codeHash, artifact.fieldsSig, artifact.eventsSig, artifact.functions);
+        const contract = new Contract(artifact.typeId, artifact.bytecode, artifact.codeHash, artifact.fieldsSig, artifact.eventsSig, artifact.functions);
         return contract;
     }
-    static fromCompileResult(result) {
-        return new Contract(result.bytecode, result.codeHash, result.fields, result.events, result.functions);
+    static fromCompileResult(typeId, result) {
+        return new Contract(typeId, result.bytecode, result.codeHash, result.fields, result.events, result.functions);
     }
     // support both 'code.ral' and 'code.ral.json'
     static async fromArtifactFile(path) {
@@ -419,6 +392,7 @@ class Contract extends Artifact {
     }
     toString() {
         const object = {
+            typeId: this.typeId,
             bytecode: this.bytecode,
             codeHash: this.codeHash,
             fieldsSig: this.fieldsSig,
@@ -439,10 +413,8 @@ class Contract extends Artifact {
             asset: asset
         };
     }
-    // no need to be cryptographically strong random
     static randomAddress() {
-        const bytes = new Uint8Array(33);
-        crypto_1.webcrypto.getRandomValues(bytes);
+        const bytes = crypto.randomBytes(33);
         bytes[0] = 3;
         return utils_1.bs58.encode(bytes);
     }
@@ -596,20 +568,20 @@ Contract.ContractDestroyedEvent = {
     fieldTypes: ['Address']
 };
 class Script extends Artifact {
-    constructor(bytecodeTemplate, fieldsSig, functions) {
-        super(functions);
+    constructor(typeId, bytecodeTemplate, fieldsSig, functions) {
+        super(typeId, functions);
         this.bytecodeTemplate = bytecodeTemplate;
         this.fieldsSig = fieldsSig;
     }
-    static fromCompileResult(result) {
-        return new Script(result.bytecodeTemplate, result.fields, result.functions);
+    static fromCompileResult(typeId, result) {
+        return new Script(typeId, result.bytecodeTemplate, result.fields, result.functions);
     }
     // TODO: safely parse json
     static fromJson(artifact) {
         if (artifact.bytecodeTemplate == null || artifact.fieldsSig == null || artifact.functions == null) {
             throw Error('The artifact JSON for script is incomplete');
         }
-        return new Script(artifact.bytecodeTemplate, artifact.fieldsSig, artifact.functions);
+        return new Script(artifact.typeId, artifact.bytecodeTemplate, artifact.fieldsSig, artifact.functions);
     }
     static async fromArtifactFile(path) {
         const content = await fs_2.promises.readFile(path);
@@ -618,6 +590,7 @@ class Script extends Artifact {
     }
     toString() {
         const object = {
+            typeId: this.typeId,
             bytecodeTemplate: this.bytecodeTemplate,
             fieldsSig: this.fieldsSig,
             functions: this.functions

package/dist/src/contract/index.js

@@ -18,11 +18,7 @@ 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;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
+    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];

package/dist/src/index.d.ts

@@ -5,4 +5,3 @@ export * from './utils';
 export * from './transaction';
 export * from './constants';
 export * from './global';
-export * as utils from './utils';

package/dist/src/index.js

@@ -18,32 +18,15 @@ 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;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
+    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 __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);
 };
-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;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.utils = void 0;
 __exportStar(require("./api"), exports);
 __exportStar(require("./contract"), exports);
 __exportStar(require("./signer"), exports);
@@ -51,4 +34,3 @@ __exportStar(require("./utils"), exports);
 __exportStar(require("./transaction"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./global"), exports);
-exports.utils = __importStar(require("./utils"));

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

@@ -1 +1,2 @@
 export * from './signer';
+export * from './node-wallet';

package/dist/src/signer/index.js

@@ -18,11 +18,7 @@ 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;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
+    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];
@@ -32,3 +28,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./signer"), exports);
+__exportStar(require("./node-wallet"), exports);

package/dist/src/signer/node-wallet.d.ts

@@ -0,0 +1,11 @@
+import { Account, SignerWithNodeProvider } from '../signer';
+export declare class NodeWallet extends SignerWithNodeProvider {
+    walletName: string;
+    accounts: Account[] | undefined;
+    constructor(walletName: string, alwaysSubmitTx?: boolean);
+    getAccounts(): Promise<Account[]>;
+    private getAllAccounts;
+    signRaw(signerAddress: string, hexString: string): Promise<string>;
+    unlock(password: string): Promise<void>;
+    lock(): Promise<void>;
+}

package/dist/src/signer/node-wallet.js

@@ -0,0 +1,57 @@
+"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.NodeWallet = void 0;
+const signer_1 = require("../signer");
+class NodeWallet extends signer_1.SignerWithNodeProvider {
+    constructor(walletName, alwaysSubmitTx = true) {
+        super(alwaysSubmitTx);
+        this.walletName = walletName;
+    }
+    async getAccounts() {
+        if (typeof this.accounts === 'undefined') {
+            this.accounts = await this.getAllAccounts();
+        }
+        return this.accounts;
+    }
+    async getAllAccounts() {
+        const walletAddresses = await this.provider.wallets.getWalletsWalletNameAddresses(this.walletName);
+        const accounts = walletAddresses.addresses.map((acc) => ({
+            publicKey: acc.publicKey,
+            address: acc.address,
+            group: acc.group
+        }));
+        return accounts;
+    }
+    async signRaw(signerAddress, hexString) {
+        const currentActiveAddressResponse = await this.provider.wallets.getWalletsWalletNameAddresses(this.walletName);
+        const { activeAddress } = currentActiveAddressResponse;
+        await this.provider.wallets.postWalletsWalletNameChangeActiveAddress(this.walletName, { address: signerAddress });
+        const { signature } = await this.provider.wallets.postWalletsWalletNameSign(this.walletName, { data: hexString });
+        await this.provider.wallets.postWalletsWalletNameChangeActiveAddress(this.walletName, { address: activeAddress }); // set the address that's active back to previous state
+        return signature;
+    }
+    async unlock(password) {
+        return await this.provider.wallets.postWalletsWalletNameUnlock(this.walletName, { password });
+    }
+    async lock() {
+        return await this.provider.wallets.postWalletsWalletNameLock(this.walletName);
+    }
+}
+exports.NodeWallet = NodeWallet;

package/dist/src/signer/signer.js

@@ -18,11 +18,7 @@ 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;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
+    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];

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

@@ -0,0 +1,6 @@
+import { NodeWallet } from '../signer';
+export declare const testWalletName = "alephium-web3-test-only-wallet";
+export declare const testAddress = "1DrDyTr9RpRsQnDnXo2YRiPzPW4ooHX5LLoqXrqfMrpQH";
+export declare const testPassword = "alph";
+export declare function testNodeWallet(): Promise<NodeWallet>;
+export * from './privatekey-wallet';

package/dist/src/test/index.js

@@ -0,0 +1,41 @@
+"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 });
+exports.testNodeWallet = exports.testPassword = exports.testAddress = exports.testWalletName = void 0;
+const signer_1 = require("../signer");
+exports.testWalletName = 'alephium-web3-test-only-wallet';
+exports.testAddress = '1DrDyTr9RpRsQnDnXo2YRiPzPW4ooHX5LLoqXrqfMrpQH';
+exports.testPassword = 'alph';
+async function testNodeWallet() {
+    const wallet = new signer_1.NodeWallet(exports.testWalletName);
+    await wallet.unlock(exports.testPassword);
+    return wallet;
+}
+exports.testNodeWallet = testNodeWallet;
+__exportStar(require("./privatekey-wallet"), exports);