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

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

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

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

@@ -62,6 +62,7 @@ export interface ConfirmedTransaction {
     gasAmount: number;
     /** @format uint256 */
     gasPrice: string;
+    coinbase: boolean;
     type: string;
 }
 export interface ContractOutput {
@@ -77,6 +78,17 @@ export interface ContractOutput {
     spent?: string;
     type: string;
 }
+export interface Event {
+    /** @format block-hash */
+    blockHash: string;
+    /** @format 32-byte-hash */
+    txHash: string;
+    contractAddress: string;
+    inputAddress?: string;
+    /** @format int32 */
+    eventIndex: number;
+    fields?: Val[];
+}
 export interface ExplorerInfo {
     releaseVersion: string;
     commit: string;
@@ -101,6 +113,10 @@ export interface Input {
 export interface InternalServerError {
     detail: string;
 }
+export declare enum IntervalType {
+    Daily = "daily",
+    Hourly = "hourly"
+}
 export interface ListBlocks {
     /** @format int32 */
     total: number;
@@ -196,6 +212,7 @@ export interface Transaction {
     gasAmount: number;
     /** @format uint256 */
     gasPrice: string;
+    coinbase: boolean;
 }
 export declare type TransactionLike = ConfirmedTransaction | UnconfirmedTransaction;
 export interface Unauthorized {
@@ -218,6 +235,35 @@ export interface UnconfirmedTransaction {
     lastSeen: number;
     type: string;
 }
+export declare type Val = ValAddress | ValArray | ValBool | ValByteVec | ValI256 | ValU256;
+export interface ValAddress {
+    /** @format address */
+    value: string;
+    type: string;
+}
+export interface ValArray {
+    value: Val[];
+    type: string;
+}
+export interface ValBool {
+    value: boolean;
+    type: string;
+}
+export interface ValByteVec {
+    /** @format hex-string */
+    value: string;
+    type: string;
+}
+export interface ValI256 {
+    /** @format bigint */
+    value: string;
+    type: string;
+}
+export interface ValU256 {
+    /** @format uint256 */
+    value: string;
+    type: string;
+}
 import 'cross-fetch/polyfill';
 export declare type QueryParamsType = Record<string | number, any>;
 export declare type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>;
@@ -324,14 +370,6 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/transactions/{transaction_hash}
          */
         getTransactionsTransactionHash: (transactionHash: string, params?: RequestParams) => Promise<ConfirmedTransaction | UnconfirmedTransaction>;
-        /**
-         * @description Get a transaction from a output reference key
-         *
-         * @tags Transactions
-         * @name GetTransactionsByOutputRefKeyOutputRefKey
-         * @request GET:/transactions/by/output-ref-key/{output_ref_key}
-         */
-        getTransactionsByOutputRefKeyOutputRefKey: (outputRefKey: string, params?: RequestParams) => Promise<Transaction>;
     };
     addresses: {
         /**
@@ -432,6 +470,14 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/addresses/{address}/tokens/{token_id}/balance
          */
         getAddressesAddressTokensTokenIdBalance: (address: string, tokenId: string, params?: RequestParams) => Promise<AddressBalance>;
+        /**
+         * @description Are the addresses used (at least 1 transaction)
+         *
+         * @tags Addresses, Addresses
+         * @name PostAddressesUsed
+         * @request POST:/addresses/used
+         */
+        postAddressesUsed: (data?: string[], params?: RequestParams) => Promise<boolean[]>;
         /**
          * No description
          *
@@ -444,16 +490,6 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
             toTs: number;
         }, params?: RequestParams) => Promise<string>;
     };
-    addressesActive: {
-        /**
-         * @description Are the addresses active (at least 1 transaction)
-         *
-         * @tags Addresses
-         * @name PostAddressesActive
-         * @request POST:/addresses-active
-         */
-        postAddressesActive: (data?: string[], params?: RequestParams) => Promise<boolean[]>;
-    };
     infos: {
         /**
          * @description Get explorer informations
@@ -584,7 +620,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
         getChartsHashrates: (query: {
             fromTs: number;
             toTs: number;
-            'interval-type': string;
+            'interval-type': IntervalType;
         }, params?: RequestParams) => Promise<Hashrate[]>;
         /**
          * @description `interval-type` query param: hourly, daily
@@ -597,7 +633,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
         getChartsTransactionsCount: (query: {
             fromTs: number;
             toTs: number;
-            'interval-type': string;
+            'interval-type': IntervalType;
         }, params?: RequestParams) => Promise<TimedCount[]>;
         /**
          * @description `interval-type` query param: hourly, daily
@@ -610,9 +646,43 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
         getChartsTransactionsCountPerChain: (query: {
             fromTs: number;
             toTs: number;
-            'interval-type': string;
+            'interval-type': IntervalType;
         }, params?: RequestParams) => Promise<PerChainTimedCount[]>;
     };
+    contractEvents: {
+        /**
+         * @description Get contract events by transaction id
+         *
+         * @tags Contract events
+         * @name GetContractEventsTransactionIdTransactionId
+         * @request GET:/contract-events/transaction-id/{transaction_id}
+         */
+        getContractEventsTransactionIdTransactionId: (transactionId: string, params?: RequestParams) => Promise<Event[]>;
+        /**
+         * @description Get contract events by contract address
+         *
+         * @tags Contract events
+         * @name GetContractEventsContractAddressContractAddress
+         * @request GET:/contract-events/contract-address/{contract_address}
+         */
+        getContractEventsContractAddressContractAddress: (contractAddress: string, query?: {
+            page?: number;
+            limit?: number;
+            reverse?: boolean;
+        }, params?: RequestParams) => Promise<Event[]>;
+        /**
+         * @description Get contract events by contract and input addresses
+         *
+         * @tags Contract events
+         * @name GetContractEventsContractAddressContractAddressInputAddressInputAddress
+         * @request GET:/contract-events/contract-address/{contract_address}/input-address/{input_address}
+         */
+        getContractEventsContractAddressContractAddressInputAddressInputAddress: (contractAddress: string, inputAddress: string, query?: {
+            page?: number;
+            limit?: number;
+            reverse?: boolean;
+        }, params?: RequestParams) => Promise<Event[]>;
+    };
     utils: {
         /**
          * @description Perform a sanity check

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

@@ -10,7 +10,12 @@
  * ---------------------------------------------------------------
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Api = exports.HttpClient = exports.ContentType = void 0;
+exports.Api = exports.HttpClient = exports.ContentType = exports.IntervalType = void 0;
+var IntervalType;
+(function (IntervalType) {
+    IntervalType["Daily"] = "daily";
+    IntervalType["Hourly"] = "hourly";
+})(IntervalType = exports.IntervalType || (exports.IntervalType = {}));
 require("cross-fetch/polyfill");
 const utils_1 = require("./utils");
 var ContentType;
@@ -210,19 +215,6 @@ class Api extends HttpClient {
                 method: 'GET',
                 format: 'json',
                 ...params
-            }).then(utils_1.convertHttpResponse),
-            /**
-             * @description Get a transaction from a output reference key
-             *
-             * @tags Transactions
-             * @name GetTransactionsByOutputRefKeyOutputRefKey
-             * @request GET:/transactions/by/output-ref-key/{output_ref_key}
-             */
-            getTransactionsByOutputRefKeyOutputRefKey: (outputRefKey, params = {}) => this.request({
-                path: `/transactions/by/output-ref-key/${outputRefKey}`,
-                method: 'GET',
-                format: 'json',
-                ...params
             }).then(utils_1.convertHttpResponse)
         };
         this.addresses = {
@@ -362,6 +354,21 @@ class Api extends HttpClient {
                 format: 'json',
                 ...params
             }).then(utils_1.convertHttpResponse),
+            /**
+             * @description Are the addresses used (at least 1 transaction)
+             *
+             * @tags Addresses, Addresses
+             * @name PostAddressesUsed
+             * @request POST:/addresses/used
+             */
+            postAddressesUsed: (data, params = {}) => this.request({
+                path: `/addresses/used`,
+                method: 'POST',
+                body: data,
+                type: ContentType.Json,
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
             /**
              * No description
              *
@@ -376,23 +383,6 @@ class Api extends HttpClient {
                 ...params
             }).then(utils_1.convertHttpResponse)
         };
-        this.addressesActive = {
-            /**
-             * @description Are the addresses active (at least 1 transaction)
-             *
-             * @tags Addresses
-             * @name PostAddressesActive
-             * @request POST:/addresses-active
-             */
-            postAddressesActive: (data, params = {}) => this.request({
-                path: `/addresses-active`,
-                method: 'POST',
-                body: data,
-                type: ContentType.Json,
-                format: 'json',
-                ...params
-            }).then(utils_1.convertHttpResponse)
-        };
         this.infos = {
             /**
              * @description Get explorer informations
@@ -601,6 +591,49 @@ class Api extends HttpClient {
                 ...params
             }).then(utils_1.convertHttpResponse)
         };
+        this.contractEvents = {
+            /**
+             * @description Get contract events by transaction id
+             *
+             * @tags Contract events
+             * @name GetContractEventsTransactionIdTransactionId
+             * @request GET:/contract-events/transaction-id/{transaction_id}
+             */
+            getContractEventsTransactionIdTransactionId: (transactionId, params = {}) => this.request({
+                path: `/contract-events/transaction-id/${transactionId}`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
+            /**
+             * @description Get contract events by contract address
+             *
+             * @tags Contract events
+             * @name GetContractEventsContractAddressContractAddress
+             * @request GET:/contract-events/contract-address/{contract_address}
+             */
+            getContractEventsContractAddressContractAddress: (contractAddress, query, params = {}) => this.request({
+                path: `/contract-events/contract-address/${contractAddress}`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
+            /**
+             * @description Get contract events by contract and input addresses
+             *
+             * @tags Contract events
+             * @name GetContractEventsContractAddressContractAddressInputAddressInputAddress
+             * @request GET:/contract-events/contract-address/{contract_address}/input-address/{input_address}
+             */
+            getContractEventsContractAddressContractAddressInputAddressInputAddress: (contractAddress, inputAddress, query, params = {}) => this.request({
+                path: `/contract-events/contract-address/${contractAddress}/input-address/${inputAddress}`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse)
+        };
         this.utils = {
             /**
              * @description Perform a sanity check

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

@@ -27,7 +27,6 @@ export declare class ExplorerProvider {
     readonly blocks: any;
     readonly transactions: any;
     readonly addresses: any;
-    readonly addressesActive: any;
     readonly infos: any;
     readonly unconfirmedTransactions: any;
     readonly tokens: any;

package/dist/src/api/index.js

@@ -119,7 +119,6 @@ class ExplorerProvider {
         this.blocks = api_explorer_1.Api['blocks'];
         this.transactions = api_explorer_1.Api['transactions'];
         this.addresses = api_explorer_1.Api['addresses'];
-        this.addressesActive = api_explorer_1.Api['addressesActive'];
         this.infos = api_explorer_1.Api['infos'];
         this.unconfirmedTransactions = api_explorer_1.Api['unconfirmedTransactions'];
         this.tokens = api_explorer_1.Api['tokens'];
@@ -142,7 +141,6 @@ class ExplorerProvider {
         this.blocks = { ...explorerApi.blocks };
         this.transactions = { ...explorerApi.transactions };
         this.addresses = { ...explorerApi.addresses };
-        this.addressesActive = { ...explorerApi.addressesActive };
         this.infos = { ...explorerApi.infos };
         this.unconfirmedTransactions = { ...explorerApi.unconfirmedTransactions };
         this.tokens = { ...explorerApi.tokens };

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

@@ -27,9 +27,10 @@ declare class SourceInfo {
     contractRelativePath: string;
     sourceCode: string;
     sourceCodeHash: string;
+    isExternal: boolean;
     getArtifactPath(artifactsRootDir: string): string;
-    constructor(type: SourceKind, name: string, sourceCode: string, sourceCodeHash: string, contractRelativePath: string);
-    static from(type: SourceKind, name: string, sourceCode: string, contractRelativePath: string): Promise<SourceInfo>;
+    constructor(type: SourceKind, name: string, sourceCode: string, sourceCodeHash: string, contractRelativePath: string, isExternal: boolean);
+    static from(type: SourceKind, name: string, sourceCode: string, contractRelativePath: string, isExternal: boolean): Promise<SourceInfo>;
 }
 declare class Compiled<T extends Artifact> {
     sourceInfo: SourceInfo;
@@ -62,6 +63,7 @@ export declare class Project {
     readonly contractsRootDir: string;
     readonly artifactsRootDir: string;
     static currentProject: Project;
+    static readonly importRegex: RegExp;
     static readonly abstractContractMatcher: TypedMatcher<SourceKind>;
     static readonly contractMatcher: TypedMatcher<SourceKind.Contract>;
     static readonly interfaceMatcher: TypedMatcher<SourceKind.Interface>;
@@ -76,11 +78,13 @@ export declare class Project {
     contractByCodeHash(codeHash: string): Contract;
     private static compile;
     private static loadArtifacts;
+    private static getImportSourcePath;
+    private static handleImports;
     private static loadSourceFile;
     private static loadSourceFiles;
     static readonly DEFAULT_CONTRACTS_DIR = "contracts";
     static readonly DEFAULT_ARTIFACTS_DIR = "artifacts";
-    static build(compilerOptionsPartial?: Partial<CompilerOptions>, contractsRootDir?: string, artifactsRootDir?: string): Promise<void>;
+    static build(compilerOptionsPartial?: Partial<CompilerOptions>, projectRootDir?: string, contractsRootDir?: string, artifactsRootDir?: string): Promise<void>;
 }
 export declare abstract class Artifact {
     readonly version: string;

package/dist/src/contract/contract.js

@@ -76,20 +76,39 @@ class TypedMatcher {
         this.type = type;
     }
 }
+function removeParentsPrefix(parts) {
+    let index = 0;
+    for (let i = 0; i < parts.length; i++) {
+        if (parts[`${i}`] === '..') {
+            index += 1;
+        }
+        else {
+            break;
+        }
+    }
+    return path.join(...parts.slice(index));
+}
 class SourceInfo {
-    constructor(type, name, sourceCode, sourceCodeHash, contractRelativePath) {
+    constructor(type, name, sourceCode, sourceCodeHash, contractRelativePath, isExternal) {
         this.type = type;
         this.name = name;
         this.sourceCode = sourceCode;
         this.sourceCodeHash = sourceCodeHash;
         this.contractRelativePath = contractRelativePath;
+        this.isExternal = isExternal;
     }
     getArtifactPath(artifactsRootDir) {
+        if (this.isExternal) {
+            const relativePath = removeParentsPrefix(this.contractRelativePath.split(path.sep));
+            const externalPath = path.join('.external', relativePath);
+            return path.join(artifactsRootDir, externalPath) + '.json';
+        }
         return path.join(artifactsRootDir, this.contractRelativePath) + '.json';
     }
-    static async from(type, name, sourceCode, contractRelativePath) {
+    static async from(type, name, sourceCode, contractRelativePath, isExternal) {
         const sourceCodeHash = await crypto_1.webcrypto.subtle.digest('SHA-256', buffer_1.Buffer.from(sourceCode));
-        return new SourceInfo(type, name, sourceCode, buffer_1.Buffer.from(sourceCodeHash).toString('hex'), contractRelativePath);
+        const sourceCodeHashHex = buffer_1.Buffer.from(sourceCodeHash).toString('hex');
+        return new SourceInfo(type, name, sourceCode, sourceCodeHashHex, contractRelativePath, isExternal);
     }
 }
 class Compiled {
@@ -301,49 +320,91 @@ class Project {
             return Project.compile(provider, sourceInfos, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
         }
     }
-    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"`);
+    static getImportSourcePath(projectRootDir, importPath) {
+        const parts = importPath.split(path.sep);
+        if (parts.length > 1 && parts[0] === 'std') {
+            const currentDir = path.dirname(__filename);
+            return path.join(...[currentDir, '..', '..', '..', importPath]);
         }
-        const sourceBuffer = await fs_2.promises.readFile(contractPath);
-        const sourceStr = sourceBuffer.toString();
-        const sourceInfos = [];
+        let moduleDir = projectRootDir;
+        while (true) {
+            const expectedPath = path.join(...[moduleDir, 'node_modules', importPath]);
+            if (fs_1.default.existsSync(expectedPath)) {
+                return expectedPath;
+            }
+            const oldModuleDir = moduleDir;
+            moduleDir = path.join(moduleDir, '..');
+            if (oldModuleDir === moduleDir) {
+                throw new Error(`Specified import file does not exist: ${importPath}`);
+            }
+        }
+    }
+    static async handleImports(projectRootDir, contractRootDir, sourceStr, importsCache) {
+        const localImportsCache = [];
+        const result = sourceStr.replace(Project.importRegex, (match) => {
+            localImportsCache.push(match);
+            return '';
+        });
+        const externalSourceInfos = [];
+        for (const myImport of localImportsCache) {
+            const originImportPath = myImport.slice(8, -1);
+            const importPath = originImportPath.endsWith('.ral') ? originImportPath : originImportPath + '.ral';
+            if (!importsCache.includes(importPath)) {
+                importsCache.push(importPath);
+                const sourcePath = Project.getImportSourcePath(projectRootDir, importPath);
+                const sourceInfos = await Project.loadSourceFile(projectRootDir, contractRootDir, sourcePath, importsCache, true);
+                externalSourceInfos.push(...sourceInfos);
+            }
+        }
+        return [result, externalSourceInfos];
+    }
+    static async loadSourceFile(projectRootDir, contractsRootDir, sourcePath, importsCache, isExternal) {
+        const contractRelativePath = path.relative(contractsRootDir, sourcePath);
+        if (!sourcePath.endsWith('.ral')) {
+            throw new Error(`Invalid filename: ${sourcePath}, smart contract file name should end with ".ral"`);
+        }
+        const sourceBuffer = await fs_2.promises.readFile(sourcePath);
+        const [sourceStr, externalSourceInfos] = await Project.handleImports(projectRootDir, contractsRootDir, sourceBuffer.toString(), importsCache);
+        if (sourceStr.match(new RegExp('^import "', 'mg')) !== null) {
+            throw new Error(`Invalid import statements, source: ${sourcePath}`);
+        }
+        const sourceInfos = externalSourceInfos;
         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);
+                const sourceInfo = await SourceInfo.from(matcher.type, result[1], sourceStr, contractRelativePath, isExternal);
                 sourceInfos.push(sourceInfo);
             }
         }
         return sourceInfos;
     }
-    static async loadSourceFiles(contractsRootDir) {
-        const loadDir = async function (dirPath, results) {
+    static async loadSourceFiles(projectRootDir, contractsRootDir) {
+        const importsCache = [];
+        const sourceInfos = [];
+        const loadDir = async function (dirPath) {
             const dirents = await fs_2.promises.readdir(dirPath, { withFileTypes: true });
             for (const dirent of dirents) {
                 if (dirent.isFile()) {
-                    const sourceInfos = await Project.loadSourceFile(contractsRootDir, dirPath, dirent.name);
-                    results.push(...sourceInfos);
+                    const sourcePath = path.join(dirPath, dirent.name);
+                    const infos = await Project.loadSourceFile(projectRootDir, contractsRootDir, sourcePath, importsCache, false);
+                    sourceInfos.push(...infos);
                 }
                 else {
                     const newPath = path.join(dirPath, dirent.name);
-                    await loadDir(newPath, results);
+                    await loadDir(newPath);
                 }
             }
         };
-        const sourceInfos = [];
-        await loadDir(contractsRootDir, sourceInfos);
+        await loadDir(contractsRootDir);
         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 sourceInfos.sort((a, b) => a.type - b.type);
     }
-    static async build(compilerOptionsPartial = {}, contractsRootDir = Project.DEFAULT_CONTRACTS_DIR, artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR) {
+    static async build(compilerOptionsPartial = {}, projectRootDir = '.', contractsRootDir = Project.DEFAULT_CONTRACTS_DIR, artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR) {
         const provider = (0, global_1.getCurrentNodeProvider)();
-        const sourceFiles = await Project.loadSourceFiles(contractsRootDir);
+        const sourceFiles = await Project.loadSourceFiles(projectRootDir, contractsRootDir);
         const { errorOnWarnings, ...nodeCompilerOptions } = { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial };
         const projectArtifact = await ProjectArtifact.from(artifactsRootDir);
         if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {
@@ -357,9 +418,10 @@ class Project {
     }
 }
 exports.Project = Project;
+Project.importRegex = new RegExp('^import "[^"./]+/[^"]*[a-z][a-z_0-9]*(.ral)?"', 'mg');
 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.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,

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

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

package/dist/src/signer/index.js

@@ -33,3 +33,4 @@ 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,6 +1,7 @@
 import { ExplorerProvider, NodeProvider } from '../api';
 import { node } from '../api';
-import { Account, Address, EnableOptionsBase, Destination, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignMessageParams, SignMessageResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult, SubmissionResult, SubmitTransactionParams } from './types';
+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;
@@ -13,15 +14,19 @@ export interface SignerProvider {
     signMessage(params: SignMessageParams): Promise<SignMessageResult>;
 }
 export interface InteractiveSignerProvider<EnableOptions extends EnableOptionsBase = EnableOptionsBase> extends SignerProvider {
-    enable(opt?: EnableOptions): Promise<void>;
+    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 implements SignerProvider {
-    abstract get nodeProvider(): NodeProvider | undefined;
+export declare abstract class SignerProviderSimple extends TransactionBuilder implements SignerProvider {
     abstract get explorerProvider(): ExplorerProvider | undefined;
     abstract getSelectedAccount(): Promise<Account>;
     getSelectedAddress(): Promise<Address>;
-    private getNodeProvider;
     submitTransaction(params: SubmitTransactionParams): Promise<SubmissionResult>;
     signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
     signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
@@ -30,11 +35,11 @@ export declare abstract class SignerProviderSimple implements SignerProvider {
     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>;