@alephium/web3 0.1.0 → 0.2.0-test.0

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

@@ -63,6 +63,8 @@ export interface Balance {
     lockedBalance: string;
     /** @format x.x ALPH */
     lockedBalanceHint: string;
+    tokenBalances?: Token[];
+    lockedTokenBalances?: Token[];
     /** @format int32 */
     utxoNum: number;
     warning?: string;

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

@@ -1,6 +1,13 @@
 import { NodeProvider } from '../api';
 import { node } from '../api';
 import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer';
+declare class SourceFile {
+    readonly dirs: string[];
+    readonly dirPath: string;
+    readonly contractPath: string;
+    readonly artifactPath: string;
+    constructor(dirs: string[], fileName: string);
+}
 export declare abstract class Common {
     readonly sourceCodeSha256: string;
     readonly functions: node.FunctionSig[];
@@ -13,16 +20,15 @@ export declare abstract class Common {
     protected static _getArtifactFromCache(codeHash: string): Contract | Script | undefined;
     protected static _putArtifactToCache(contract: Contract): void;
     constructor(sourceCodeSha256: string, functions: node.FunctionSig[]);
-    protected static _contractPath(fileName: string): string;
-    protected static _artifactPath(fileName: string): string;
     protected static _artifactsFolder(): string;
-    protected static _handleImports(contractStr: string, importsCache: string[]): Promise<string>;
-    protected static _loadContractStr(fileName: string, importsCache: string[], validate: (fileName: string) => void): Promise<string>;
+    static getSourceFile(path: string, _dirs: string[]): SourceFile;
+    protected static _handleImports(pathes: string[], contractStr: string, importsCache: string[]): Promise<string>;
+    protected static _loadContractStr(sourceFile: SourceFile, importsCache: string[], validate: (code: string) => void): Promise<string>;
     static checkFileNameExtension(fileName: string): void;
     protected static _from<T extends {
         sourceCodeSha256: string;
-    }>(provider: NodeProvider, fileName: string, loadContractStr: (fileName: string, importsCache: string[]) => Promise<string>, compile: (provider: NodeProvider, fileName: string, contractStr: string, contractHash: string) => Promise<T>): Promise<T>;
-    protected _saveToFile(fileName: string): Promise<void>;
+    }>(provider: NodeProvider, sourceFile: SourceFile, loadContractStr: (sourceFile: SourceFile, importsCache: string[]) => Promise<string>, compile: (provider: NodeProvider, sourceFile: SourceFile, contractStr: string, contractHash: string) => Promise<T>): Promise<T>;
+    protected _saveToFile(sourceFile: SourceFile): Promise<void>;
     abstract buildByteCodeToDeploy(initialFields?: Fields): string;
 }
 export declare class Contract extends Common {
@@ -33,10 +39,11 @@ export declare class Contract extends Common {
     constructor(sourceCodeSha256: string, bytecode: string, codeHash: string, fieldsSig: node.FieldsSig, eventsSig: node.EventSig[], functions: node.FunctionSig[]);
     static checkCodeType(fileName: string, contractStr: string): void;
     private static loadContractStr;
-    static fromSource(provider: NodeProvider, fileName: string): Promise<Contract>;
+    static fromSource(provider: NodeProvider, path: string): Promise<Contract>;
     private static compile;
     static fromJson(artifact: any): Contract;
-    static fromArtifactFile(fileName: string): Promise<Contract>;
+    static fromArtifactFile(path: string): Promise<Contract>;
+    fetchState(provider: NodeProvider, address: string, group: number): Promise<ContractState>;
     toString(): string;
     toState(fields: Fields, asset: Asset, address?: string): ContractState;
     static randomAddress(): string;
@@ -65,10 +72,10 @@ export declare class Script extends Common {
     constructor(sourceCodeSha256: string, bytecodeTemplate: string, fieldsSig: node.FieldsSig, functions: node.FunctionSig[]);
     static checkCodeType(fileName: string, contractStr: string): void;
     private static loadContractStr;
-    static fromSource(provider: NodeProvider, fileName: string): Promise<Script>;
+    static fromSource(provider: NodeProvider, path: string): Promise<Script>;
     private static compile;
     static fromJson(artifact: any): Script;
-    static fromArtifactFile(fileName: string): Promise<Script>;
+    static fromArtifactFile(path: string): Promise<Script>;
     toString(): string;
     paramsForDeployment(params: BuildExecuteScriptTx): Promise<SignExecuteScriptTxParams>;
     transactionForDeployment(signer: SignerWithNodeProvider, params: Omit<BuildExecuteScriptTx, 'signerAddress'>): Promise<BuildScriptTxResult>;
@@ -180,3 +187,4 @@ export interface BuildScriptTxResult {
     unsignedTx: string;
     txId: string;
 }
+export {};

package/dist/src/contract/contract.js

@@ -47,6 +47,20 @@ const fs_1 = __importDefault(require("fs"));
 const fs_2 = require("fs");
 const ralph = __importStar(require("./ralph"));
 const utils_1 = require("../utils");
+class SourceFile {
+    constructor(dirs, fileName) {
+        this.dirs = dirs;
+        this.dirPath = dirs.length === 0 ? '' : dirs.join('/') + '/';
+        if (fileName.endsWith('.json')) {
+            this.contractPath = './contracts/' + this.dirPath + fileName.slice(0, -5);
+            this.artifactPath = './artifacts/' + this.dirPath + fileName;
+        }
+        else {
+            this.contractPath = './contracts/' + this.dirPath + fileName;
+            this.artifactPath = './artifacts/' + this.dirPath + fileName + '.json';
+        }
+    }
+}
 class Common {
     constructor(sourceCodeSha256, functions) {
         this.sourceCodeSha256 = sourceCodeSha256;
@@ -64,72 +78,85 @@ class Common {
             this._artifactCache.set(contract.codeHash, contract);
         }
     }
-    static _contractPath(fileName) {
-        if (fileName.endsWith('.json')) {
-            return `./contracts/${fileName.slice(0, -5)}`;
-        }
-        else {
-            return `./contracts/${fileName}`;
-        }
-    }
-    static _artifactPath(fileName) {
-        if (fileName.endsWith('.json')) {
-            return `./artifacts/${fileName}`;
-        }
-        else {
-            return `./artifacts/${fileName}.json`;
-        }
-    }
     static _artifactsFolder() {
         return './artifacts/';
     }
-    static async _handleImports(contractStr, importsCache) {
+    static getSourceFile(path, _dirs) {
+        const parts = path.split('/');
+        const dirs = Array.from(_dirs);
+        if (parts.length === 1) {
+            return new SourceFile(dirs, path);
+        }
+        parts.slice(0, parts.length - 1).forEach((part) => {
+            switch (part) {
+                case '.': {
+                    break;
+                }
+                case '..': {
+                    if (dirs.length === 0) {
+                        throw new Error('Invalid file path: ' + path);
+                    }
+                    dirs.pop();
+                    break;
+                }
+                default: {
+                    dirs.push(part);
+                }
+            }
+        });
+        return new SourceFile(dirs, parts[parts.length - 1]);
+    }
+    static async _handleImports(pathes, contractStr, importsCache) {
         const localImportsCache = [];
         let result = contractStr.replace(Common.importRegex, (match) => {
             localImportsCache.push(match);
             return '';
         });
         for (const myImport of localImportsCache) {
-            const fileName = myImport.slice(8, -1);
-            if (!importsCache.includes(fileName)) {
-                importsCache.push(fileName);
-                const importContractStr = await Common._loadContractStr(fileName, importsCache, (code) => Contract.checkCodeType(fileName, code));
+            const relativePath = myImport.slice(8, -1);
+            const importSourceFile = this.getSourceFile(relativePath, pathes);
+            if (!importsCache.includes(importSourceFile.contractPath)) {
+                importsCache.push(importSourceFile.contractPath);
+                const importContractStr = await Common._loadContractStr(importSourceFile, importsCache, (code) => Contract.checkCodeType(importSourceFile.contractPath, code));
                 result = result.concat('\n', importContractStr);
             }
         }
         return result;
     }
-    static async _loadContractStr(fileName, importsCache, validate) {
-        const contractPath = this._contractPath(fileName);
+    static async _loadContractStr(sourceFile, importsCache, validate) {
+        const contractPath = sourceFile.contractPath;
         const contractBuffer = await fs_2.promises.readFile(contractPath);
         const contractStr = contractBuffer.toString();
         validate(contractStr);
-        return Common._handleImports(contractStr, importsCache);
+        return Common._handleImports(sourceFile.dirs, contractStr, importsCache);
     }
     static checkFileNameExtension(fileName) {
         if (!fileName.endsWith('.ral')) {
             throw new Error('Smart contract file name should end with ".ral"');
         }
     }
-    static async _from(provider, fileName, loadContractStr, compile) {
-        Common.checkFileNameExtension(fileName);
-        const contractStr = await loadContractStr(fileName, []);
+    static async _from(provider, sourceFile, loadContractStr, compile) {
+        Common.checkFileNameExtension(sourceFile.contractPath);
+        const contractStr = await loadContractStr(sourceFile, []);
         const contractHash = cryptojs.SHA256(contractStr).toString();
         const existingContract = this._getArtifactFromCache(contractHash);
         if (typeof existingContract !== 'undefined') {
             return existingContract;
         }
         else {
-            return compile(provider, fileName, contractStr, contractHash);
+            return compile(provider, sourceFile, contractStr, contractHash);
         }
     }
-    _saveToFile(fileName) {
-        const artifactPath = Common._artifactPath(fileName);
-        return fs_2.promises.writeFile(artifactPath, this.toString());
+    _saveToFile(sourceFile) {
+        const folder = Common._artifactsFolder() + sourceFile.dirPath;
+        if (!fs_1.default.existsSync(folder)) {
+            fs_1.default.mkdirSync(folder, { recursive: true });
+        }
+        return fs_2.promises.writeFile(sourceFile.artifactPath, this.toString());
     }
 }
 exports.Common = Common;
-Common.importRegex = new RegExp('^import "[a-z][a-z_0-9]*.ral"', 'mg');
+Common.importRegex = new RegExp('^import "([^"/]+/(([^"]+)/)?)?[a-z][a-z_0-9]*.ral"', 'mg');
 Common.contractRegex = new RegExp('^TxContract [A-Z][a-zA-Z0-9]*', 'mg');
 Common.interfaceRegex = new RegExp('^Interface [A-Z][a-zA-Z0-9]* \\{', 'mg');
 Common.scriptRegex = new RegExp('^TxScript [A-Z][a-zA-Z0-9]*', 'mg');
@@ -145,35 +172,40 @@ class Contract extends Common {
     }
     static checkCodeType(fileName, contractStr) {
         const interfaceMatches = contractStr.match(Contract.interfaceRegex);
-        if (interfaceMatches) {
-            return;
-        }
         const contractMatches = contractStr.match(Contract.contractRegex);
-        if (contractMatches === null) {
+        if (interfaceMatches === null && contractMatches === null) {
             throw new Error(`No contract found in: ${fileName}`);
         }
-        else if (contractMatches.length > 1) {
-            throw new Error(`Multiple contracts in: ${fileName}`);
+        if (interfaceMatches && contractMatches) {
+            throw new Error(`Multiple contracts and interfaces in: ${fileName}`);
         }
-        else {
-            return;
+        if (interfaceMatches === null) {
+            if (contractMatches !== null && contractMatches.length > 1) {
+                throw new Error(`Multiple contracts in: ${fileName}`);
+            }
+        }
+        if (contractMatches === null) {
+            if (interfaceMatches !== null && interfaceMatches.length > 1) {
+                throw new Error(`Multiple interfaces in: ${fileName}`);
+            }
         }
     }
-    static async loadContractStr(fileName, importsCache) {
-        return Common._loadContractStr(fileName, importsCache, (code) => Contract.checkCodeType(fileName, code));
+    static async loadContractStr(sourceFile) {
+        return Common._loadContractStr(sourceFile, [], (code) => Contract.checkCodeType(sourceFile.contractPath, code));
     }
-    static async fromSource(provider, fileName) {
+    static async fromSource(provider, path) {
         if (!fs_1.default.existsSync(Common._artifactsFolder())) {
             fs_1.default.mkdirSync(Common._artifactsFolder(), { recursive: true });
         }
-        const contract = await Common._from(provider, fileName, (fileName, importCaches) => Contract.loadContractStr(fileName, importCaches), Contract.compile);
+        const sourceFile = this.getSourceFile(path, []);
+        const contract = await Common._from(provider, sourceFile, (sourceFile) => Contract.loadContractStr(sourceFile), Contract.compile);
         this._putArtifactToCache(contract);
         return contract;
     }
-    static async compile(provider, fileName, contractStr, contractHash) {
+    static async compile(provider, sourceFile, contractStr, contractHash) {
         const compiled = await provider.contracts.postContractsCompileContract({ code: contractStr });
         const artifact = new Contract(contractHash, compiled.bytecode, compiled.codeHash, compiled.fields, compiled.events, compiled.functions);
-        await artifact._saveToFile(fileName);
+        await artifact._saveToFile(sourceFile);
         return artifact;
     }
     // TODO: safely parse json
@@ -191,12 +223,17 @@ class Contract extends Common {
         return contract;
     }
     // support both 'code.ral' and 'code.ral.json'
-    static async fromArtifactFile(fileName) {
-        const artifactPath = Contract._artifactPath(fileName);
+    static async fromArtifactFile(path) {
+        const sourceFile = this.getSourceFile(path, []);
+        const artifactPath = sourceFile.artifactPath;
         const content = await fs_2.promises.readFile(artifactPath);
         const artifact = JSON.parse(content.toString());
         return Contract.fromJson(artifact);
     }
+    async fetchState(provider, address, group) {
+        const state = await provider.contracts.getContractsAddressState(address, { group: group });
+        return this.fromApiContractState(state);
+    }
     toString() {
         return JSON.stringify({
             sourceCodeSha256: this.sourceCodeSha256,
@@ -415,16 +452,17 @@ class Script extends Common {
             return;
         }
     }
-    static async loadContractStr(fileName, importsCache) {
-        return Common._loadContractStr(fileName, importsCache, (code) => Script.checkCodeType(fileName, code));
+    static async loadContractStr(sourceFile) {
+        return Common._loadContractStr(sourceFile, [], (code) => Script.checkCodeType(sourceFile.contractPath, code));
     }
-    static async fromSource(provider, fileName) {
-        return Common._from(provider, fileName, (fileName, importsCache) => Script.loadContractStr(fileName, importsCache), Script.compile);
+    static async fromSource(provider, path) {
+        const sourceFile = this.getSourceFile(path, []);
+        return Common._from(provider, sourceFile, (sourceFile) => Script.loadContractStr(sourceFile), Script.compile);
     }
-    static async compile(provider, fileName, scriptStr, contractHash) {
+    static async compile(provider, sourceFile, scriptStr, contractHash) {
         const compiled = await provider.contracts.postContractsCompileScript({ code: scriptStr });
         const artifact = new Script(contractHash, compiled.bytecodeTemplate, compiled.fields, compiled.functions);
-        await artifact._saveToFile(fileName);
+        await artifact._saveToFile(sourceFile);
         return artifact;
     }
     // TODO: safely parse json
@@ -437,8 +475,9 @@ class Script extends Common {
         }
         return new Script(artifact.sourceCodeSha256, artifact.bytecodeTemplate, artifact.fieldsSig, artifact.functions);
     }
-    static async fromArtifactFile(fileName) {
-        const artifactPath = Common._artifactPath(fileName);
+    static async fromArtifactFile(path) {
+        const sourceFile = this.getSourceFile(path, []);
+        const artifactPath = sourceFile.artifactPath;
         const content = await fs_2.promises.readFile(artifactPath);
         const artifact = JSON.parse(content.toString());
         return this.fromJson(artifact);

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

@@ -1,29 +1,11 @@
-import { node } from '../api';
-import { NodeProvider } from '../api';
-declare type EventCallback = (event: node.ContractEvent) => Promise<void>;
-declare type ErrorCallback = (error: any, subscription: Subscription) => Promise<void>;
-export interface SubscribeOptions {
-    provider: NodeProvider;
-    contractAddress: string;
-    fromCount?: number;
-    pollingInterval: number;
-    eventCallback: EventCallback;
-    errorCallback: ErrorCallback;
-}
-export declare class Subscription {
-    provider: NodeProvider;
+import { ContractEvent } from '../api/api-alephium';
+import { Subscription, SubscribeOptions } from '../utils';
+export declare class EventSubscription extends Subscription<ContractEvent> {
     readonly contractAddress: string;
-    pollingInterval: number;
     private fromCount;
-    private eventCallback;
-    private errorCallback;
-    private task;
-    private cancelled;
-    private eventEmitter;
-    constructor(options: SubscribeOptions);
-    unsubscribe(): void;
+    constructor(options: SubscribeOptions<ContractEvent>, contractAddress: string, fromCount?: number);
+    startPolling(): void;
     currentEventCount(): number;
-    private fetchEvents;
+    polling(): Promise<void>;
 }
-export declare function subscribe(options: SubscribeOptions): Subscription;
-export {};
+export declare function subscribeToEvents(options: SubscribeOptions<ContractEvent>, contractAddress: string, fromCount?: number): EventSubscription;

package/dist/src/contract/events.js

@@ -16,39 +16,26 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.subscribe = exports.Subscription = void 0;
-const eventemitter3_1 = __importDefault(require("eventemitter3"));
-class Subscription {
-    constructor(options) {
-        this.provider = options.provider;
-        this.contractAddress = options.contractAddress;
-        this.fromCount = typeof options.fromCount === 'undefined' ? 0 : options.fromCount;
-        this.pollingInterval = options.pollingInterval;
-        this.eventCallback = options.eventCallback;
-        this.errorCallback = options.errorCallback;
-        this.task = undefined;
-        this.cancelled = false;
-        this.eventEmitter = new eventemitter3_1.default();
+exports.subscribeToEvents = exports.EventSubscription = void 0;
+const utils_1 = require("../utils");
+class EventSubscription extends utils_1.Subscription {
+    constructor(options, contractAddress, fromCount) {
+        super(options);
+        this.contractAddress = contractAddress;
+        this.fromCount = typeof fromCount === 'undefined' ? 0 : fromCount;
+        this.startPolling();
+    }
+    startPolling() {
         this.eventEmitter.on('tick', async () => {
-            await this.fetchEvents();
+            await this.polling();
         });
         this.eventEmitter.emit('tick');
     }
-    unsubscribe() {
-        this.eventEmitter.removeAllListeners();
-        this.cancelled = true;
-        if (typeof this.task !== 'undefined') {
-            clearTimeout(this.task);
-        }
-    }
     currentEventCount() {
         return this.fromCount;
     }
-    async fetchEvents() {
+    async polling() {
         try {
             const events = await this.provider.events.getEventsContractContractaddress(this.contractAddress, {
                 start: this.fromCount
@@ -60,18 +47,18 @@ class Subscription {
                 this.task = setTimeout(() => this.eventEmitter.emit('tick'), this.pollingInterval);
                 return;
             }
-            const promises = events.events.map((event) => this.eventCallback(event));
+            const promises = events.events.map((event) => this.messageCallback(event));
             await Promise.all(promises);
             this.fromCount = events.nextStart;
-            await this.fetchEvents();
+            await this.polling();
         }
         catch (err) {
             await this.errorCallback(err, this);
         }
     }
 }
-exports.Subscription = Subscription;
-function subscribe(options) {
-    return new Subscription(options);
+exports.EventSubscription = EventSubscription;
+function subscribeToEvents(options, contractAddress, fromCount) {
+    return new EventSubscription(options, contractAddress, fromCount);
 }
-exports.subscribe = subscribe;
+exports.subscribeToEvents = subscribeToEvents;

package/dist/src/index.d.ts

@@ -2,4 +2,5 @@ export * from './api';
 export * from './contract';
 export * from './signer';
 export * from './utils';
+export * from './transaction';
 export * from './constants';

package/dist/src/index.js

@@ -31,4 +31,5 @@ __exportStar(require("./api"), exports);
 __exportStar(require("./contract"), exports);
 __exportStar(require("./signer"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./transaction"), exports);
 __exportStar(require("./constants"), exports);

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

@@ -0,0 +1,2 @@
+export * from './sign-verify';
+export * from './status';

package/dist/src/transaction/index.js

@@ -0,0 +1,31 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sign-verify"), exports);
+__exportStar(require("./status"), exports);

package/dist/src/{utils/transaction.js → transaction/sign-verify.js}

@@ -38,7 +38,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transactionVerifySignature = exports.transactionSign = void 0;
 const elliptic_1 = require("elliptic");
-const utils = __importStar(require("./utils"));
+const utils = __importStar(require("../utils"));
 const ec = new elliptic_1.ec('secp256k1');
 function transactionSign(txHash, privateKey) {
     const keyPair = ec.keyFromPrivate(privateKey);

package/dist/src/transaction/status.d.ts

@@ -0,0 +1,10 @@
+import { TxStatus } from '../api/api-alephium';
+import { Subscription, SubscribeOptions } from '../utils';
+export declare class TxStatusSubscription extends Subscription<TxStatus> {
+    readonly txId: string;
+    readonly fromGroup?: number;
+    readonly toGroup?: number;
+    constructor(options: SubscribeOptions<TxStatus>, txId: string, fromGroup?: number, toGroup?: number);
+    polling(): Promise<void>;
+}
+export declare function subscribeToTxStatus(options: SubscribeOptions<TxStatus>, txId: string, fromGroup?: number, toGroup?: number): TxStatusSubscription;

package/dist/src/transaction/status.js

@@ -0,0 +1,48 @@
+"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.subscribeToTxStatus = exports.TxStatusSubscription = void 0;
+const utils_1 = require("../utils");
+class TxStatusSubscription extends utils_1.Subscription {
+    constructor(options, txId, fromGroup, toGroup) {
+        super(options);
+        this.txId = txId;
+        this.fromGroup = fromGroup;
+        this.toGroup = toGroup;
+        this.startPolling();
+    }
+    async polling() {
+        try {
+            const txStatus = await this.provider.transactions.getTransactionsStatus({
+                txId: this.txId,
+                fromGroup: this.fromGroup,
+                toGroup: this.toGroup
+            });
+            await this.messageCallback(txStatus);
+        }
+        catch (err) {
+            await this.errorCallback(err, this);
+        }
+    }
+}
+exports.TxStatusSubscription = TxStatusSubscription;
+function subscribeToTxStatus(options, txId, fromGroup, toGroup) {
+    return new TxStatusSubscription(options, txId, fromGroup, toGroup);
+}
+exports.subscribeToTxStatus = subscribeToTxStatus;

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

@@ -2,5 +2,5 @@ export * from './address';
 export * from './bs58';
 export * from './djb2';
 export * from './password-crypto';
-export * from './transaction';
 export * from './utils';
+export * from './subscription';

package/dist/src/utils/index.js

@@ -31,5 +31,5 @@ __exportStar(require("./address"), exports);
 __exportStar(require("./bs58"), exports);
 __exportStar(require("./djb2"), exports);
 __exportStar(require("./password-crypto"), exports);
-__exportStar(require("./transaction"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./subscription"), exports);

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

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