@alephium/web3 0.3.0-rc.3 → 0.3.0-rc.5

package/dist/src/api/api-alephium.d.ts

@@ -908,7 +908,7 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 1.6.0
+ * @version 1.6.1
  * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

package/dist/src/api/api-alephium.js

@@ -149,7 +149,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 1.6.0
+ * @version 1.6.1
  * @baseUrl ../
  */
 class Api extends HttpClient {

package/dist/src/contract/contract.d.ts

@@ -5,7 +5,7 @@ export declare type EventSig = node.EventSig;
 export declare type FunctionSig = node.FunctionSig;
 export declare type Fields = NamedVals;
 export declare type Arguments = NamedVals;
-declare enum SourceType {
+declare enum SourceKind {
     Contract = 0,
     Script = 1,
     AbstractContract = 2,
@@ -16,28 +16,29 @@ export declare type CompilerOptions = node.CompilerOptions & {
 };
 export declare const DEFAULT_NODE_COMPILER_OPTIONS: node.CompilerOptions;
 export declare const DEFAULT_COMPILER_OPTIONS: CompilerOptions;
-declare class TypedMatcher<T extends SourceType> {
+declare class TypedMatcher<T extends SourceKind> {
     matcher: RegExp;
     type: T;
     constructor(pattern: string, type: T);
-    match(str: string): number;
 }
-declare class SourceFile {
-    type: SourceType;
-    contractPath: string;
+declare class SourceInfo {
+    type: SourceKind;
+    name: string;
+    contractRelativePath: string;
     sourceCode: string;
     sourceCodeHash: string;
     getArtifactPath(artifactsRootDir: string): string;
-    constructor(type: SourceType, sourceCode: string, sourceCodeHash: string, contractPath: string);
-    static from(type: SourceType, sourceCode: string, contractPath: string): Promise<SourceFile>;
+    constructor(type: SourceKind, name: string, sourceCode: string, sourceCodeHash: string, contractRelativePath: string);
+    static from(type: SourceKind, name: string, sourceCode: string, contractRelativePath: string): Promise<SourceInfo>;
 }
 declare class Compiled<T extends Artifact> {
-    sourceFile: SourceFile;
+    sourceInfo: SourceInfo;
     artifact: T;
     warnings: string[];
-    constructor(sourceFile: SourceFile, artifact: T, warnings: string[]);
+    constructor(sourceInfo: SourceInfo, artifact: T, warnings: string[]);
 }
 declare type CodeInfo = {
+    sourceFile: string;
     sourceCodeHash: string;
     bytecodeDebugPatch: string;
     codeHashDebug: string;
@@ -50,25 +51,24 @@ declare class ProjectArtifact {
     static checkCompilerOptionsParameter(compilerOptions: node.CompilerOptions): void;
     constructor(compilerOptionsUsed: node.CompilerOptions, infos: Map<string, CodeInfo>);
     saveToFile(rootPath: string): Promise<void>;
-    needToReCompile(compilerOptions: node.CompilerOptions, files: SourceFile[]): boolean;
+    needToReCompile(compilerOptions: node.CompilerOptions, sourceInfos: SourceInfo[]): boolean;
     static from(rootPath: string): Promise<ProjectArtifact | undefined>;
 }
 export declare class Project {
-    sourceFiles: SourceFile[];
-    contracts: Compiled<Contract>[];
-    scripts: Compiled<Script>[];
+    sourceInfos: SourceInfo[];
+    contracts: Map<string, Compiled<Contract>>;
+    scripts: Map<string, Compiled<Script>>;
     projectArtifact: ProjectArtifact;
     readonly contractsRootDir: string;
     readonly artifactsRootDir: string;
     static currentProject: Project;
-    static readonly abstractContractMatcher: TypedMatcher<SourceType>;
-    static readonly contractMatcher: TypedMatcher<SourceType.Contract>;
-    static readonly interfaceMatcher: TypedMatcher<SourceType.Interface>;
-    static readonly scriptMatcher: TypedMatcher<SourceType.Script>;
-    static readonly matchers: TypedMatcher<SourceType>[];
-    static buildProjectArtifact(sourceFiles: SourceFile[], contracts: Compiled<Contract>[], scripts: Compiled<Script>[], compilerOptions: node.CompilerOptions): ProjectArtifact;
+    static readonly abstractContractMatcher: TypedMatcher<SourceKind>;
+    static readonly contractMatcher: TypedMatcher<SourceKind.Contract>;
+    static readonly interfaceMatcher: TypedMatcher<SourceKind.Interface>;
+    static readonly scriptMatcher: TypedMatcher<SourceKind.Script>;
+    static readonly matchers: TypedMatcher<SourceKind>[];
+    static buildProjectArtifact(sourceInfos: SourceInfo[], contracts: Map<string, Compiled<Contract>>, scripts: Map<string, Compiled<Script>>, compilerOptions: node.CompilerOptions): ProjectArtifact;
     private constructor();
-    private getContractPath;
     static checkCompilerWarnings(warnings: string[], errorOnWarnings: boolean): void;
     static contract(name: string): Contract;
     static script(name: string): Script;

package/dist/src/contract/contract.js

@@ -53,13 +53,14 @@ const ralph = __importStar(require("./ralph"));
 const utils_1 = require("../utils");
 const global_1 = require("../global");
 const __1 = require("..");
-var SourceType;
-(function (SourceType) {
-    SourceType[SourceType["Contract"] = 0] = "Contract";
-    SourceType[SourceType["Script"] = 1] = "Script";
-    SourceType[SourceType["AbstractContract"] = 2] = "AbstractContract";
-    SourceType[SourceType["Interface"] = 3] = "Interface";
-})(SourceType || (SourceType = {}));
+const path = __importStar(require("path"));
+var SourceKind;
+(function (SourceKind) {
+    SourceKind[SourceKind["Contract"] = 0] = "Contract";
+    SourceKind[SourceKind["Script"] = 1] = "Script";
+    SourceKind[SourceKind["AbstractContract"] = 2] = "AbstractContract";
+    SourceKind[SourceKind["Interface"] = 3] = "Interface";
+})(SourceKind || (SourceKind = {}));
 exports.DEFAULT_NODE_COMPILER_OPTIONS = {
     ignoreUnusedConstantsWarnings: false,
     ignoreUnusedVariablesWarnings: false,
@@ -74,29 +75,26 @@ class TypedMatcher {
         this.matcher = new RegExp(pattern, 'mg');
         this.type = type;
     }
-    match(str) {
-        const results = str.match(this.matcher);
-        return results === null ? 0 : results.length;
-    }
 }
-class SourceFile {
-    constructor(type, sourceCode, sourceCodeHash, contractPath) {
+class SourceInfo {
+    constructor(type, name, sourceCode, sourceCodeHash, contractRelativePath) {
         this.type = type;
+        this.name = name;
         this.sourceCode = sourceCode;
         this.sourceCodeHash = sourceCodeHash;
-        this.contractPath = contractPath;
+        this.contractRelativePath = contractRelativePath;
     }
     getArtifactPath(artifactsRootDir) {
-        return artifactsRootDir + this.contractPath.slice(this.contractPath.indexOf('/')) + '.json';
+        return path.join(artifactsRootDir, this.contractRelativePath) + '.json';
     }
-    static async from(type, sourceCode, contractPath) {
+    static async from(type, name, sourceCode, contractRelativePath) {
         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);
+        return new SourceInfo(type, name, sourceCode, buffer_1.Buffer.from(sourceCodeHash).toString('hex'), contractRelativePath);
     }
 }
 class Compiled {
-    constructor(sourceFile, artifact, warnings) {
-        this.sourceFile = sourceFile;
+    constructor(sourceInfo, artifact, warnings) {
+        this.sourceInfo = sourceInfo;
         this.artifact = artifact;
         this.warnings = warnings;
     }
@@ -117,12 +115,15 @@ class ProjectArtifact {
         }
     }
     async saveToFile(rootPath) {
-        const filepath = rootPath + '/' + ProjectArtifact.artifactFileName;
-        const artifact = { compilerOptionsUsed: this.compilerOptionsUsed, infos: Object.fromEntries(this.infos) };
+        const filepath = path.join(rootPath, ProjectArtifact.artifactFileName);
+        const artifact = {
+            compilerOptionsUsed: this.compilerOptionsUsed,
+            infos: Object.fromEntries(new Map([...this.infos].sort()))
+        };
         const content = JSON.stringify(artifact, null, 2);
         return fs_2.promises.writeFile(filepath, content);
     }
-    needToReCompile(compilerOptions, files) {
+    needToReCompile(compilerOptions, sourceInfos) {
         ProjectArtifact.checkCompilerOptionsParameter(compilerOptions);
         const optionsMatched = Object.entries(compilerOptions).every(([key, inputOption]) => {
             const usedOption = this.compilerOptionsUsed[`${key}`];
@@ -131,19 +132,19 @@ class ProjectArtifact {
         if (!optionsMatched) {
             return true;
         }
-        if (files.length !== this.infos.size) {
+        if (sourceInfos.length !== this.infos.size) {
             return true;
         }
-        for (const file of files) {
-            const info = this.infos.get(file.contractPath);
-            if (typeof info === 'undefined' || info.sourceCodeHash !== file.sourceCodeHash) {
+        for (const sourceInfo of sourceInfos) {
+            const info = this.infos.get(sourceInfo.name);
+            if (typeof info === 'undefined' || info.sourceCodeHash !== sourceInfo.sourceCodeHash) {
                 return true;
             }
         }
         return false;
     }
     static async from(rootPath) {
-        const filepath = rootPath + '/' + ProjectArtifact.artifactFileName;
+        const filepath = path.join(rootPath, ProjectArtifact.artifactFileName);
         if (!fs_1.default.existsSync(filepath)) {
             return undefined;
         }
@@ -156,38 +157,44 @@ class ProjectArtifact {
 }
 ProjectArtifact.artifactFileName = '.project.json';
 class Project {
-    constructor(contractsRootDir, artifactsRootDir, sourceFiles, contracts, scripts, errorOnWarnings, projectArtifact) {
+    constructor(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, errorOnWarnings, projectArtifact) {
         this.contractsRootDir = contractsRootDir;
         this.artifactsRootDir = artifactsRootDir;
-        this.sourceFiles = sourceFiles;
+        this.sourceInfos = sourceInfos;
         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);
+            Project.checkCompilerWarnings([
+                ...[...contracts.entries()].map((c) => c[1].warnings).flat(),
+                ...[...scripts.entries()].map((s) => s[1].warnings).flat()
+            ], errorOnWarnings);
         }
     }
-    static buildProjectArtifact(sourceFiles, contracts, scripts, compilerOptions) {
+    static buildProjectArtifact(sourceInfos, contracts, scripts, compilerOptions) {
         const files = new Map();
         contracts.forEach((c) => {
-            files.set(c.sourceFile.contractPath, {
-                sourceCodeHash: c.sourceFile.sourceCodeHash,
+            files.set(c.artifact.name, {
+                sourceFile: c.sourceInfo.contractRelativePath,
+                sourceCodeHash: c.sourceInfo.sourceCodeHash,
                 bytecodeDebugPatch: c.artifact.bytecodeDebugPatch,
                 codeHashDebug: c.artifact.codeHashDebug,
                 warnings: c.warnings
             });
         });
         scripts.forEach((s) => {
-            files.set(s.sourceFile.contractPath, {
-                sourceCodeHash: s.sourceFile.sourceCodeHash,
+            files.set(s.artifact.name, {
+                sourceFile: s.sourceInfo.contractRelativePath,
+                sourceCodeHash: s.sourceInfo.sourceCodeHash,
                 bytecodeDebugPatch: s.artifact.bytecodeDebugPatch,
                 codeHashDebug: '',
                 warnings: s.warnings
             });
         });
-        const compiledSize = contracts.length + scripts.length;
-        sourceFiles.slice(compiledSize).forEach((c) => {
-            files.set(c.contractPath, {
+        const compiledSize = contracts.size + scripts.size;
+        sourceInfos.slice(compiledSize).forEach((c) => {
+            files.set(c.name, {
+                sourceFile: c.contractRelativePath,
                 sourceCodeHash: c.sourceCodeHash,
                 bytecodeDebugPatch: '',
                 codeHashDebug: '',
@@ -196,13 +203,6 @@ class Project {
         });
         return new ProjectArtifact(compilerOptions, files);
     }
-    getContractPath(path) {
-        return path.startsWith(`./${this.contractsRootDir}`)
-            ? path.slice(2)
-            : path.startsWith(this.contractsRootDir)
-                ? path
-                : this.contractsRootDir + '/' + path;
-    }
     static checkCompilerWarnings(warnings, errorOnWarnings) {
         if (warnings.length !== 0) {
             const prefixPerWarning = '  - ';
@@ -217,14 +217,14 @@ class Project {
         }
     }
     static contract(name) {
-        const contract = Project.currentProject.contracts.find((c) => c.artifact.name === name);
+        const contract = Project.currentProject.contracts.get(name);
         if (typeof contract === 'undefined') {
             throw new Error(`Contract "${name}" does not exist`);
         }
         return contract.artifact;
     }
     static script(name) {
-        const script = Project.currentProject.scripts.find((c) => c.artifact.name === name);
+        const script = Project.currentProject.scripts.get(name);
         if (typeof script === 'undefined') {
             throw new Error(`Script "${name}" does not exist`);
         }
@@ -233,118 +233,113 @@ class Project {
     async saveArtifactsToFile() {
         const artifactsRootDir = this.artifactsRootDir;
         const saveToFile = async function (compiled) {
-            const artifactDir = compiled.sourceFile.getArtifactPath(artifactsRootDir);
-            const folder = artifactDir.slice(0, artifactDir.lastIndexOf('/'));
-            if (!fs_1.default.existsSync(folder)) {
-                fs_1.default.mkdirSync(folder, { recursive: true });
+            const artifactPath = compiled.sourceInfo.getArtifactPath(artifactsRootDir);
+            const dirname = path.dirname(artifactPath);
+            if (!fs_1.default.existsSync(dirname)) {
+                fs_1.default.mkdirSync(dirname, { recursive: true });
             }
-            return fs_2.promises.writeFile(artifactDir, compiled.artifact.toString());
+            return fs_2.promises.writeFile(artifactPath, compiled.artifact.toString());
         };
-        for (const contract of this.contracts) {
-            saveToFile(contract);
-        }
-        for (const script of this.scripts) {
-            await saveToFile(script);
-        }
+        this.contracts.forEach((contract) => saveToFile(contract));
+        this.scripts.forEach((script) => saveToFile(script));
         await this.projectArtifact.saveToFile(this.artifactsRootDir);
     }
     contractByCodeHash(codeHash) {
-        const contract = this.contracts.find((c) => c.artifact.codeHash === codeHash || c.artifact.codeHashDebug == codeHash);
+        const contract = [...this.contracts.values()].find((c) => c.artifact.codeHash === codeHash || c.artifact.codeHashDebug == codeHash);
         if (typeof contract === 'undefined') {
             throw new Error(`Unknown code with code hash: ${codeHash}`);
         }
         return contract.artifact;
     }
-    static async compile(provider, files, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
-        const sourceStr = files.map((f) => f.sourceCode).join('\n');
+    static async compile(provider, sourceInfos, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
+        const sourceStr = sourceInfos.map((f) => f.sourceCode).join('\n');
         const result = await provider.contracts.postContractsCompileProject({
             code: sourceStr,
             compilerOptions: compilerOptions
         });
-        const contracts = [];
-        const scripts = [];
+        const contracts = new Map();
+        const scripts = new Map();
         result.contracts.forEach((contractResult, index) => {
-            const sourceFile = files[`${index}`];
+            const sourceInfo = sourceInfos[`${index}`];
             const contract = Contract.fromCompileResult(contractResult);
-            contracts.push(new Compiled(sourceFile, contract, contractResult.warnings));
+            contracts.set(contract.name, new Compiled(sourceInfo, contract, contractResult.warnings));
         });
         result.scripts.forEach((scriptResult, index) => {
-            const sourceFile = files[index + contracts.length];
+            const sourceInfo = sourceInfos[index + contracts.size];
             const script = Script.fromCompileResult(scriptResult);
-            scripts.push(new Compiled(sourceFile, script, scriptResult.warnings));
+            scripts.set(script.name, new Compiled(sourceInfo, script, scriptResult.warnings));
         });
-        const projectArtifact = Project.buildProjectArtifact(files, contracts, scripts, compilerOptions);
-        const project = new Project(contractsRootDir, artifactsRootDir, files, contracts, scripts, errorOnWarnings, projectArtifact);
+        const projectArtifact = Project.buildProjectArtifact(sourceInfos, contracts, scripts, compilerOptions);
+        const project = new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, errorOnWarnings, projectArtifact);
         await project.saveArtifactsToFile();
         return project;
     }
-    static async loadArtifacts(provider, files, projectArtifact, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
+    static async loadArtifacts(provider, sourceInfos, projectArtifact, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
         try {
-            const contracts = [];
-            const scripts = [];
-            for (const file of files) {
-                const info = projectArtifact.infos.get(file.contractPath);
+            const contracts = new Map();
+            const scripts = new Map();
+            for (const sourceInfo of sourceInfos) {
+                const info = projectArtifact.infos.get(sourceInfo.name);
                 if (typeof info === 'undefined') {
-                    throw Error(`Unable to find project info for ${file.contractPath}, please rebuild the project`);
+                    throw Error(`Unable to find project info for ${sourceInfo.name}, please rebuild the project`);
                 }
                 const warnings = info.warnings;
-                const artifactDir = file.getArtifactPath(artifactsRootDir);
-                if (file.type === SourceType.Contract) {
+                const artifactDir = sourceInfo.getArtifactPath(artifactsRootDir);
+                if (sourceInfo.type === SourceKind.Contract) {
                     const artifact = await Contract.fromArtifactFile(artifactDir, info.bytecodeDebugPatch, info.codeHashDebug);
-                    contracts.push(new Compiled(file, artifact, warnings));
+                    contracts.set(artifact.name, new Compiled(sourceInfo, artifact, warnings));
                 }
-                else if (file.type === SourceType.Script) {
+                else if (sourceInfo.type === SourceKind.Script) {
                     const artifact = await Script.fromArtifactFile(artifactDir, info.bytecodeDebugPatch);
-                    scripts.push(new Compiled(file, artifact, warnings));
+                    scripts.set(artifact.name, new Compiled(sourceInfo, artifact, warnings));
                 }
             }
-            return new Project(contractsRootDir, artifactsRootDir, files, contracts, scripts, errorOnWarnings, projectArtifact);
+            return new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, errorOnWarnings, projectArtifact);
         }
         catch (error) {
             console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`);
-            return Project.compile(provider, files, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
+            return Project.compile(provider, sourceInfos, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
         }
     }
-    static async loadSourceFile(dirPath, filename) {
-        const contractPath = dirPath + '/' + filename;
+    static async loadSourceFile(contractsRootDir, dirPath, filename) {
+        const contractPath = path.join(dirPath, filename);
+        const contractRelativePath = path.relative(contractsRootDir, contractPath);
         if (!filename.endsWith('.ral')) {
             throw new Error(`Invalid filename: ${contractPath}, smart contract file name should end with ".ral"`);
         }
         const sourceBuffer = await fs_2.promises.readFile(contractPath);
         const sourceStr = sourceBuffer.toString();
-        const results = this.matchers.map((m) => m.match(sourceStr));
-        const matchNumber = results.reduce((a, b) => a + b, 0);
-        if (matchNumber === 0) {
-            throw new Error(`No contract defined in file: ${contractPath}`);
-        }
-        if (matchNumber > 1) {
-            throw new Error(`Multiple definitions in file: ${contractPath}`);
+        const sourceInfos = [];
+        for (const matcher of this.matchers) {
+            const results = sourceStr.matchAll(matcher.matcher);
+            for (const result of results) {
+                const sourceInfo = await SourceInfo.from(matcher.type, result[1], sourceStr, contractRelativePath);
+                sourceInfos.push(sourceInfo);
+            }
         }
-        const matcherIndex = results.indexOf(1);
-        const type = this.matchers[`${matcherIndex}`].type;
-        return SourceFile.from(type, sourceStr, contractPath);
+        return sourceInfos;
     }
     static async loadSourceFiles(contractsRootDir) {
         const loadDir = async function (dirPath, results) {
             const dirents = await fs_2.promises.readdir(dirPath, { withFileTypes: true });
             for (const dirent of dirents) {
                 if (dirent.isFile()) {
-                    const file = await Project.loadSourceFile(dirPath, dirent.name);
-                    results.push(file);
+                    const sourceInfos = await Project.loadSourceFile(contractsRootDir, dirPath, dirent.name);
+                    results.push(...sourceInfos);
                 }
                 else {
-                    const newPath = dirPath + '/' + dirent.name;
+                    const newPath = path.join(dirPath, dirent.name);
                     await loadDir(newPath, results);
                 }
             }
         };
-        const sourceFiles = [];
-        await loadDir(contractsRootDir, sourceFiles);
-        const contractAndScriptSize = sourceFiles.filter((f) => f.type === SourceType.Contract || f.type === SourceType.Script).length;
-        if (sourceFiles.length === 0 || contractAndScriptSize === 0) {
+        const sourceInfos = [];
+        await loadDir(contractsRootDir, sourceInfos);
+        const contractAndScriptSize = sourceInfos.filter((f) => f.type === SourceKind.Contract || f.type === SourceKind.Script).length;
+        if (sourceInfos.length === 0 || contractAndScriptSize === 0) {
             throw new Error('Project have no source files');
         }
-        return sourceFiles.sort((a, b) => a.type - b.type);
+        return sourceInfos.sort((a, b) => a.type - b.type);
     }
     static async build(compilerOptionsPartial = {}, contractsRootDir = Project.DEFAULT_CONTRACTS_DIR, artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR) {
         const provider = (0, global_1.getCurrentNodeProvider)();
@@ -362,10 +357,10 @@ class Project {
     }
 }
 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]*)', SourceKind.AbstractContract);
+Project.contractMatcher = new TypedMatcher('^Contract ([A-Z][a-zA-Z0-9]*)', SourceKind.Contract);
+Project.interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*) \\{', SourceKind.Interface);
+Project.scriptMatcher = new TypedMatcher('^TxScript ([A-Z][a-zA-Z0-9]*)', SourceKind.Script);
 Project.matchers = [
     Project.abstractContractMatcher,
     Project.contractMatcher,
@@ -591,7 +586,7 @@ class Contract extends Artifact {
     async txParamsForDeployment(signer, params) {
         const bytecode = this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {});
         const signerParams = {
-            signerAddress: (await signer.getSelectedAccount()).address,
+            signerAddress: await signer.getSelectedAddress(),
             bytecode: bytecode,
             initialAttoAlphAmount: params.initialAttoAlphAmount,
             issueTokenAmount: params.issueTokenAmount,
@@ -658,7 +653,7 @@ class Script extends Artifact {
     }
     async txParamsForExecution(signer, params) {
         const signerParams = {
-            signerAddress: (await signer.getSelectedAccount()).address,
+            signerAddress: await signer.getSelectedAddress(),
             bytecode: this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {}),
             attoAlphAmount: params.attoAlphAmount,
             tokens: params.tokens,

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

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

package/dist/src/signer/index.js

@@ -32,3 +32,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./signer"), exports);
+__exportStar(require("./types"), exports);