suidouble 0.0.17 → 0.0.18

package/README.md

@@ -9,6 +9,7 @@ Set of provider, package and object classes for javascript representation of Sui
     - [Interacting with smart contract](#interacting-with-smart-contract)
     - [SuiObject](#suiobject)
     - [Fetching Events](#fetching-events)
+    - [Subscribe to Events](#subscribing-to-events)
     - [Executing smart contract method](#executing-smart-contract-method)
     - [Fetching objects](#fetching-objects)
 - [Publishing the package](#publishing-the-package)
@@ -138,6 +139,35 @@ while (events.hasNextPage) {
 // const events = await contract.fetchEvents('modulename', {order: 'descending'}); // or all module events
 ```
 
+##### subscribing to events
+
+You can subscribe to Sui's contract events on package's module level. No types-etc filters for now ( @todo? )
+
+```javascript
+const module = await contract.getModule('suidouble_chat');
+await module.subscribeEvents();
+module.addEventListener('ChatResponseCreated', (suiEvent)=>{
+    // received message emited by 
+    // emit(ChatResponseCreated { id: object::uid_to_inner(&chat_response_id), top_message_id: object::uid_to_inner(&id), seq_n: 0 });
+    // in suidouble_chat 's smart contract
+    console.log(suiEvent.typeName); // == 'ChatResponseCreated'
+    console.log(suiEvent.parsedJson);
+});
+module.addEventListener('ChatTopMessageCreated', (suiEvent)=>{
+    // received message emited by 
+    // emit(ChatTopMessageCreated { id: object::uid_to_inner(&id), top_response_id: object::uid_to_inner(&chat_response_id),  });
+    // in suidouble_chat 's smart contract
+    console.log(suiEvent.typeName); // == 'ChatTopMessageCreated'
+    console.log(suiEvent.parsedJson);
+});
+```
+
+Don't forget to unsubscribe from events when you don't need them anymore:
+
+```javascript
+await module.unsubscribeEvents();
+```
+
 ##### executing smart contract method
 
 ```javascript

package/lib/SuiCommonMethods.js

@@ -34,7 +34,11 @@ class SuiCommonMethods extends EventTarget {
 
 	emit(eventType, data) {
 		try {
-			this.dispatchEvent(new CustomEvent(eventType, { detail: data }));
+			if (data.isSuiEvent) {
+				this.dispatchEvent(data);
+			} else {
+				this.dispatchEvent(new CustomEvent(eventType, { detail: data }));
+			}
 		} catch (e) {
 			console.error(e);
 		}

package/lib/SuiEvent.js

@@ -1,15 +1,36 @@
 const SuiCommonMethods = require('./SuiCommonMethods.js');
 
-class SuiEvent extends SuiCommonMethods {
+class SuiEvent extends Event {
     constructor(params = {}) {
-        super(params);
+        const typeName = params.data ? (params.data.type.split('::').pop()) : null;
+        super(typeName, {});
 
+        this._debug = !!params.debug;
         this._suiMaster = params.suiMaster;
         if (!this._suiMaster) {
             throw new Error('suiMaster is requried for suiPackage');
         }
 
         this._data = params.data || {};
+
+        this.detail = this; // quick backward support as this is the instance of CustomEvent
+    }
+
+	log(...args) {
+		if (!this._debug) {
+			return;
+		}
+
+		let prefix = (this._suiMaster ? (''+this._suiMaster.instanceN+' |') : (this.instanceN ? ''+this.instanceN+' |' : '') );
+		// prefix += this.constructor.name+' | ';
+
+		args.unshift(this.constructor.name+' |');
+		args.unshift(prefix);
+		console.info.apply(null, args);
+	}
+
+    get isSuiEvent() {
+        return true;
     }
 
     /**

package/lib/SuiLocalTestValidator.js

@@ -105,7 +105,6 @@ class SuiLocalTestValidator extends SuiCommonMethods {
         });
 
         process.on('exit', ()=>{
-            console.log('this._testFallbackEnabled', this._testFallbackEnabled);
             if (this._child) {
                 this._child.kill();
             }

package/lib/SuiPackageModule.js

@@ -3,6 +3,7 @@ const SuiObject = require('./SuiObject.js');
 
 const SuiCommonMethods = require('./SuiCommonMethods.js');
 const SuiPaginatedResponse = require('./SuiPaginatedResponse.js');
+const SuiEvent = require('./SuiEvent.js');
 // fromB64, toB64
 
 class SuiPackageModule extends SuiCommonMethods {
@@ -28,6 +29,43 @@ class SuiPackageModule extends SuiCommonMethods {
         // we need to get very first version's address of this package to use for types, so we are doing this in separate call
         this._checkedOnChain = false;
         this._normalizedMoveModule = {};
+
+        this._unsubscribeFunction = null;
+    }
+
+    async subscribeEvents() {
+        this.log('subscribing to events of module', this._moduleName);
+
+        // we need very first package version's id here. So we are getting it from normalized data
+        const normalizedPackageAddress = await this.getNormalizedPackageAddress();
+
+        const onMessage = (rawEvent) => {
+            const suiEvent = new SuiEvent({
+                suiMaster: this._suiMaster,
+                debug: this._debug,
+                data: rawEvent,
+            });
+
+            const eventTypeName = suiEvent.typeName;
+            this.log('got event', eventTypeName);
+            this.emit(eventTypeName, suiEvent);
+        };
+
+        this._unsubscribeFunction = await this._suiMaster._provider.subscribeEvent({
+            filter: {"MoveModule": {"package": normalizedPackageAddress, "module": this._moduleName} },
+            onMessage: onMessage,
+        });
+    }
+
+    async unsubscribeEvents() {
+        if (this._unsubscribeFunction) {
+            await this._unsubscribeFunction();
+            this._unsubscribeFunction = null;
+            
+            return true;
+        }
+
+        return false;
     }
 
     get objectStorage() {
@@ -181,8 +219,15 @@ class SuiPackageModule extends SuiCommonMethods {
                 const eventType = event.type;
                 const eventTypeName = eventType.split(':').pop(); // last name, without package and module names
 
-                const eventData = event.parsedJson;
-                this.emit(eventTypeName, eventData);
+                // const eventData = event.parsedJson;
+
+                const suiEvent = new SuiEvent({
+                    suiMaster: this._suiMaster,
+                    debug: this._debug,
+                    data: event,
+                });
+
+                this.emit(eventTypeName, suiEvent);
             }
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "suidouble",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "description": "Set of provider, package and object classes for javascript representation of Sui Move smart contracts. Use same code for publishing, upgrading, integration testing, interaction with smart contracts and integration in browser web3 dapps",
   "main": "index.js",
   "scripts": {
@@ -21,7 +21,7 @@
   "author": "Jeka Kiselyov <jeka911@gmail.com> (https://github.com/jeka-kiselyov)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@mysten/sui.js": "^0.34.0",
+    "@mysten/sui.js": "^0.35.1",
     "@wallet-standard/core": "^1.0.3"
   },
   "devDependencies": {

package/test/sui_master_onlocal.test.js

@@ -25,7 +25,7 @@ test('spawn local test node', async t => {
 });
 
 test('init suiMaster and connect it to local test validator', async t => {
-    suiMaster = new SuiMaster({provider: suiLocalTestValidator, as: 'somebody', debug: false});
+    suiMaster = new SuiMaster({provider: suiLocalTestValidator, as: 'somebody', debug: true});
     await suiMaster.initialize();
 
     t.ok(suiMaster.address); // there should be some address
@@ -150,6 +150,34 @@ test('can find a package on the blockchain by expected module name (in owned)',
     t.equal(contract.version, 2);
 });
 
+test('subscribe to module events', async t => {
+    const module = await contract.getModule('suidouble_chat');
+    await module.subscribeEvents();
+
+    let gotEventChatTopMessageCreated = false;
+    let gotEventChatResponseCreated = false;
+
+    module.addEventListener('ChatTopMessageCreated', (event)=>{
+        gotEventChatTopMessageCreated = event;
+    });
+    module.addEventListener('ChatResponseCreated', (event)=>{
+        gotEventChatResponseCreated = event.detail; // .detail is reference to event itself. To support CustomEvent pattern
+    });
+
+    await contract.moveCall('suidouble_chat', 'post', [chatShopObjectId, 'the message', 'metadata']);
+    await new Promise((res)=>setTimeout(res, 300)); // got events without timeout, but just to be sure.
+
+    t.ok(gotEventChatTopMessageCreated);
+    t.ok(gotEventChatResponseCreated);
+
+    // just some checks that events have data by contract's architecture
+    t.ok(gotEventChatResponseCreated.parsedJson.top_message_id == gotEventChatTopMessageCreated.parsedJson.id);
+    t.ok(gotEventChatTopMessageCreated.parsedJson.top_response_id == gotEventChatResponseCreated.parsedJson.id);
+
+    // unsubscribing from events, to close websocket
+    await module.unsubscribeEvents();
+});
+
 test('execute contract methods', async t => {
     const moveCallResult = await contract.moveCall('suidouble_chat', 'post', [chatShopObjectId, 'the message', 'metadata']);
 
@@ -290,5 +318,5 @@ test('testing move call with coins', async t => {
 });
 
 test('stops local test node', async t => {
-    SuiLocalTestValidator.stop();
+    await SuiLocalTestValidator.stop();
 });