suidouble 0.0.16 → 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
@@ -305,6 +335,15 @@ suiInBrowser.addEventListener('connected', async()=>{
 
 ```
 
+### Unit tests
+
+```bash
+npm install
+npm run tests
+```
+
+Take a look at [unit tests](test) code for some inspiration.
+
 ### Todo
 
 - subscribe to events

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/SuiMaster.js

@@ -15,8 +15,13 @@ class SuiMaster extends SuiCommonMethods {
         this._signer = null;
         this._keypair = null;
 
+        this._address = null;
+
         if (params.signer) {
             this._signer = params.signer;
+            if (this._signer && this._signer.connectedAddress) {
+                this._address = this._signer.connectedAddress;
+            }
         } else if (params.keypair) {
             this._keypair = params.keypair;
         } else if (params.phrase) {
@@ -86,8 +91,6 @@ class SuiMaster extends SuiCommonMethods {
 
         this._initialized = false;
 
-        this._address = null;
-
         this._packages = {};
     }
 

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.16",
+  "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();
 });

package/test/test_move_contracts/suidouble_color/Move.lock

@@ -0,0 +1,20 @@
+# @generated by Move, please check-in and do not edit manually.
+
+[move]
+version = 0
+
+dependencies = [
+  { name = "Sui" },
+]
+
+[[move.package]]
+name = "MoveStdlib"
+source = { git = "https://github.com/MystenLabs/sui.git", rev = "testnet", subdir = "crates/sui-framework/packages/move-stdlib" }
+
+[[move.package]]
+name = "Sui"
+source = { git = "https://github.com/MystenLabs/sui.git", rev = "testnet", subdir = "crates/sui-framework/packages/sui-framework" }
+
+dependencies = [
+  { name = "MoveStdlib" },
+]

package/test/test_move_contracts/suidouble_color/Move.toml

@@ -0,0 +1,10 @@
+[package]
+name = "suidouble_color"
+version = "0.0.1"
+
+[dependencies]
+Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "testnet" }
+
+[addresses]
+suidouble_color =  "0x0"
+sui =  "0000000000000000000000000000000000000000000000000000000000000002"

package/test/test_move_contracts/suidouble_color/sources/suidouble_color.move

@@ -0,0 +1,150 @@
+
+module suidouble_color::suidouble_color {
+    use sui::tx_context::{Self, sender, TxContext};
+    use std::string::{Self, utf8, String};
+    use sui::transfer;
+    use sui::object::{Self, UID, ID};
+    use std::vector::{Self, append, insert};
+
+    use sui::event::emit;
+    
+    // The creator bundle: these two packages often go together.
+    use sui::package;
+    use sui::display;
+
+    /// Text size overflow.
+    const EInvalidColor: u64 = 0;
+
+    // ======== Events =========
+
+    /// Event. When a new color minted
+    struct ColorCreated has copy, drop { id: ID, r: u8, g: u8, b: u8 }
+
+    /// The Hero - an outstanding collection of digital art.
+    struct Color has key, store {
+        id: UID,
+        name: String,
+        r: u8,
+        g: u8,
+        b: u8,
+        img_url: String,
+    }
+
+    /// One-Time-Witness for the module.
+    struct SUIDOUBLE_COLOR has drop {}
+
+    /// In the module initializer we claim the `Publisher` object
+    /// to then create a `Display`. The `Display` is initialized with
+    /// a set of fields (but can be modified later) and published via
+    /// the `update_version` call.
+    ///
+    /// Keys and values are set in the initializer but could also be
+    /// set after publishing if a `Publisher` object was created.
+    fun init(otw: SUIDOUBLE_COLOR, ctx: &mut TxContext) {
+        let keys = vector[
+            utf8(b"name"),
+            utf8(b"link"),
+            utf8(b"image_url"),
+            utf8(b"description"),
+            utf8(b"project_url"),
+            utf8(b"creator"),
+        ];
+
+        let values = vector[
+            utf8(b"{name}"),
+            // For `link` we can build a URL using an `id` property
+            utf8(b"https://suidouble-color.herokuapp.com/color/{id}"),
+            utf8(b"{img_url}"),
+            // Description is static for all `Color` objects.
+            utf8(b"What a nice color. Isn't it?"),
+            // Project URL is usually static
+            utf8(b"https://suidouble-color.herokuapp.com/"),
+            // Creator field can be any
+            utf8(b"Jeka")
+        ];
+
+        // Claim the `Publisher` for the package!
+        let publisher = package::claim(otw, ctx);
+
+        // Get a new `Display` object for the `Color` type.
+        let display = display::new_with_fields<Color>(
+            &publisher, keys, values, ctx
+        );
+
+        // Commit first version of `Display` to apply changes.
+        display::update_version(&mut display);
+
+        transfer::public_transfer(publisher, sender(ctx));
+        transfer::public_transfer(display, sender(ctx));
+    }
+
+    /// Anyone can mint their `Color`!
+    public entry fun mint(name: String, r: u8, g: u8, b: u8, ctx: &mut TxContext) {
+        assert!(r >= 0 && r <= 255, EInvalidColor);
+        assert!(g >= 0 && g <= 255, EInvalidColor);
+        assert!(b >= 0 && b <= 255, EInvalidColor);
+
+        let id = object::new(ctx);
+
+        emit(ColorCreated { id: object::uid_to_inner(&id), r, g, b,  });
+
+        // constructing the smallest (1x1) GIF with the color of RGB
+        let gif_start = vector<u8>[71, 73, 70, 56, 57, 97, 1, 0, 1, 0, 128, 1, 0];
+        let gif_end = vector<u8>[0, 0, 0, 33, 249, 4, 1, 10, 0, 1, 0, 44, 0, 0, 0, 0, 1, 0, 1, 0, 0, 2, 2, 68, 1, 0, 59];
+            
+        insert(&mut gif_start, r, 13);  // appending R
+        insert(&mut gif_start, g, 14);   // appending G
+        insert(&mut gif_start, b, 15); // appending B
+        append(&mut gif_start, gif_end);
+
+        let img_url = encode(&gif_start);
+
+        let base_prefix = b"data:image/gif;base64,";
+        let as_string = utf8(base_prefix);
+        string::append(&mut as_string, utf8(img_url));
+
+        // 
+        let color = Color { id, name, img_url: as_string, r: r, g: g, b: b };
+
+        transfer::transfer(color, tx_context::sender(ctx));
+    }
+
+    // thanks to: https://github.com/movefuns/movefuns/blob/dd1f4443c6bf0bc761b27e28fb6ba00f10636840/stdlib/sources/base64.move#L2
+    const TABLE: vector<u8> = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+    public fun encode(str: &vector<u8>): vector<u8> {
+        if (vector::is_empty(str)) {
+            return vector::empty<u8>()
+        };
+        let size = vector::length(str);
+        let eq: u8 = 61;
+        let res = vector::empty<u8>();
+
+        let m = 0 ;
+        while (m < size ) {
+            vector::push_back(&mut res, *vector::borrow(&TABLE, (((*vector::borrow(str, m) & 0xfc) >> 2) as u64)));
+            if ( m + 3 >= size) {
+                if ( size % 3 == 1) {
+                    vector::push_back(&mut res, *vector::borrow(&TABLE, (((*vector::borrow(str, m) & 0x03) << 4) as u64)));
+                    vector::push_back(&mut res, eq);
+                    vector::push_back(&mut res, eq);
+                }else if (size % 3 == 2) {
+                    vector::push_back(&mut res, *vector::borrow(&TABLE, ((((*vector::borrow(str, m) & 0x03) << 4) + ((*vector::borrow(str, m + 1) & 0xf0) >> 4)) as u64)));
+                    vector::push_back(&mut res, *vector::borrow(&TABLE, (((*vector::borrow(str, m + 1) & 0x0f) << 2) as u64)));
+                    vector::push_back(&mut res, eq);
+                }else {
+                    vector::push_back(&mut res, *vector::borrow(&TABLE, ((((*vector::borrow(str, m) & 0x03) << 4) + ((*vector::borrow(str, m + 1) & 0xf0) >> 4)) as u64)));
+                    vector::push_back(&mut res, *vector::borrow(&TABLE, ((((*vector::borrow(str, m + 1) & 0x0f) << 2) + ((*vector::borrow(str, m + 2) & 0xc0) >> 6)) as u64)));
+                    vector::push_back(&mut res, *vector::borrow(&TABLE, ((*vector::borrow(str, m + 2) & 0x3f) as u64)));
+                };
+            }else {
+                vector::push_back(&mut res, *vector::borrow(&TABLE, ((((*vector::borrow(str, m) & 0x03) << 4) + ((*vector::borrow(str, m + 1) & 0xf0) >> 4)) as u64)));
+                vector::push_back(&mut res, *vector::borrow(&TABLE, ((((*vector::borrow(str, m + 1) & 0x0f) << 2) + ((*vector::borrow(str, m + 2) & 0xc0) >> 6)) as u64)));
+                vector::push_back(&mut res, *vector::borrow(&TABLE, ((*vector::borrow(str, m + 2) & 0x3f) as u64)));
+            };
+            m = m + 3;
+        };
+
+        return res
+    }
+}