@alephium/web3 0.3.0-rc.4 → 0.3.0-rc.7

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,3 @@
 export * from './signer';
+export * from './types';
+export * from './tx-builder';

package/dist/src/signer/index.js

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

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

@@ -1,100 +1,11 @@
-import { ExplorerProvider, NodeProvider, Number256, Token } from '../api';
+import { ExplorerProvider, NodeProvider } from '../api';
 import { node } from '../api';
-export declare type OutputRef = node.OutputRef;
-export interface Account {
-    address: string;
-    group: number;
-    publicKey: string;
-}
-export declare type SignerAddress = {
-    signerAddress: string;
-};
-export interface SignTransferTxParams {
-    signerAddress: string;
-    destinations: Destination[];
-    utxos?: OutputRef[];
-    gasAmount?: number;
-    gasPrice?: Number256;
-}
-export interface SignTransferTxResult {
-    fromGroup: number;
-    toGroup: number;
-    unsignedTx: string;
-    txId: string;
-    signature: string;
-    gasAmount: number;
-    gasPrice: Number256;
-}
-export interface SignDeployContractTxParams {
-    signerAddress: string;
-    bytecode: string;
-    initialAttoAlphAmount?: Number256;
-    initialTokenAmounts?: Token[];
-    issueTokenAmount?: Number256;
-    gasAmount?: number;
-    gasPrice?: Number256;
-}
-export interface SignDeployContractTxResult {
-    fromGroup: number;
-    toGroup: number;
-    unsignedTx: string;
-    txId: string;
-    signature: string;
-    contractId: string;
-    contractAddress: string;
-    gasAmount: number;
-    gasPrice: Number256;
-}
-export interface SignExecuteScriptTxParams {
-    signerAddress: string;
-    bytecode: string;
-    attoAlphAmount?: Number256;
-    tokens?: Token[];
-    gasAmount?: number;
-    gasPrice?: Number256;
-}
-export interface SignExecuteScriptTxResult {
-    fromGroup: number;
-    toGroup: number;
-    unsignedTx: string;
-    txId: string;
-    signature: string;
-    gasAmount: number;
-    gasPrice: Number256;
-}
-export interface SignUnsignedTxParams {
-    signerAddress: string;
-    unsignedTx: string;
-}
-export interface SignUnsignedTxResult {
-    fromGroup: number;
-    toGroup: number;
-    unsignedTx: string;
-    txId: string;
-    signature: string;
-    gasAmount: number;
-    gasPrice: Number256;
-}
-export interface SignMessageParams {
-    signerAddress: string;
-    message: string;
-}
-export interface SignMessageResult {
-    signature: string;
-}
-export interface SubmitTransactionParams {
-    unsignedTx: string;
-    signature: string;
-}
-export interface SubmissionResult {
-    txId: string;
-    fromGroup: number;
-    toGroup: number;
-}
+import { Account, Address, EnableOptionsBase, Destination, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignMessageParams, SignMessageResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult, SubmissionResult, SubmitTransactionParams, ExtSignTransferTxParams, ExtSignDeployContractTxParams, ExtSignExecuteScriptTxParams, ExtSignUnsignedTxParams, ExtSignMessageParams } from './types';
+import { TransactionBuilder } from './tx-builder';
 export interface SignerProvider {
     get nodeProvider(): NodeProvider | undefined;
     get explorerProvider(): ExplorerProvider | undefined;
-    getSelectedAccount(): Promise<Account>;
+    getSelectedAddress(): Promise<Address>;
     signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
     signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
     signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
@@ -102,41 +13,53 @@ export interface SignerProvider {
     signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
     signMessage(params: SignMessageParams): Promise<SignMessageResult>;
 }
-export declare abstract class SignerProviderSimple implements SignerProvider {
-    abstract get nodeProvider(): NodeProvider | undefined;
+export interface InteractiveSignerProvider<EnableOptions extends EnableOptionsBase = EnableOptionsBase> extends SignerProvider {
+    enable(opt?: EnableOptions): Promise<Address>;
+    disconnect(): Promise<void>;
+    signAndSubmitTransferTx(params: ExtSignTransferTxParams): Promise<SignTransferTxResult>;
+    signAndSubmitDeployContractTx(params: ExtSignDeployContractTxParams): Promise<SignDeployContractTxResult>;
+    signAndSubmitExecuteScriptTx(params: ExtSignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
+    signAndSubmitUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    signUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    signMessage(params: ExtSignMessageParams): Promise<SignMessageResult>;
+}
+export declare abstract class SignerProviderSimple extends TransactionBuilder implements SignerProvider {
     abstract get explorerProvider(): ExplorerProvider | undefined;
     abstract getSelectedAccount(): Promise<Account>;
-    private getNodeProvider;
+    getSelectedAddress(): Promise<Address>;
     submitTransaction(params: SubmitTransactionParams): Promise<SubmissionResult>;
     signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
     signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
     signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
     signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    protected abstract getPublicKey(address: string): Promise<string>;
     private usePublicKey;
     signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
-    buildTransferTx(params: SignTransferTxParams): Promise<node.BuildTransactionResult>;
+    buildTransferTx(params: SignTransferTxParams): Promise<Omit<SignTransferTxResult, 'signature'>>;
     signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
-    buildContractCreationTx(params: SignDeployContractTxParams): Promise<node.BuildDeployContractTxResult>;
+    buildDeployContractTx(params: SignDeployContractTxParams): Promise<Omit<SignDeployContractTxResult, 'signature'>>;
     signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
-    buildScriptTx(params: SignExecuteScriptTxParams): Promise<node.BuildExecuteScriptTxResult>;
+    buildExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<Omit<SignExecuteScriptTxResult, 'signature'>>;
     signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
     signMessage(params: SignMessageParams): Promise<SignMessageResult>;
     abstract signRaw(signerAddress: string, hexString: string): Promise<string>;
 }
 export declare abstract class SignerProviderWithMultipleAccounts extends SignerProviderSimple {
+    abstract setSelectedAddress(address: string): Promise<void>;
     abstract getAccounts(): Promise<Account[]>;
     getAccount(signerAddress: string): Promise<Account>;
-    abstract setSelectedAccount(address: string): Promise<void>;
+    getPublicKey(signerAddress: string): Promise<string>;
+}
+export declare abstract class SignerProviderWithCachedAccounts<T extends Account> extends SignerProviderWithMultipleAccounts {
+    private _selectedAccount;
+    protected readonly _accounts: Map<string, T>;
+    getSelectedAccount(): Promise<T>;
+    setSelectedAddress(address: string): Promise<void>;
+    getAccounts(): Promise<T[]>;
+    getAccount(address: string): Promise<T>;
 }
 export declare function verifyHexString(hexString: string, publicKey: string, signature: string): boolean;
 export declare function verifySignedMessage(message: string, publicKey: string, signature: string): boolean;
-export interface Destination {
-    address: string;
-    attoAlphAmount: Number256;
-    tokens?: Token[];
-    lockTime?: number;
-    message?: string;
-}
 export declare function toApiDestination(data: Destination): node.Destination;
 export declare function toApiDestinations(data: Destination[]): node.Destination[];
 export declare function fromApiDestination(data: node.Destination): Destination;