suidouble 0.0.15 → 0.0.17

package/README.md

@@ -17,6 +17,7 @@ Set of provider, package and object classes for javascript representation of Sui
 - [Connecting web3 dapps to Sui](#sui-move-connect-in-browser)
 - [Todo](#todo)
 
+Also take a look at sample Vue dapp application [source code](https://github.com/suidouble/suidouble-sample-app) or [check it online](https://suidouble-sample-app.herokuapp.com/).
 
 ### installation
 
@@ -304,6 +305,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/SuiCliCommands.js

@@ -20,14 +20,40 @@ class SuiCliCommands {
             throw new Error('can not spawn a proccess in this env');
         }
 
-        const proc = doSpawn(command, [], {
-            env: {
-                ...process.env,
-                ...envVars,
-            }
+        return await new Promise((res,rej)=>{
+            let success = true;
+            let e = null;
+            const proc = doSpawn(command, [], {
+                env: {
+                    ...process.env,
+                    ...envVars,
+                }
+            });
+            proc.on('error', function(err) {
+                success = false;
+                e = err;
+            });
+
+            setTimeout(()=>{
+                if (success) {
+                    res(proc);
+                } else {
+                    rej(e);
+                }
+            }, 100);
         });
 
-        return proc;
+        // const proc = doSpawn(command, [], {
+        //     env: {
+        //         ...process.env,
+        //         ...envVars,
+        //     }
+        // });
+        // proc.on('error', function(err) {
+        //     console.log('Oh noez, teh errurz: ' + err);
+        // });
+
+        // return proc;
     }
 
     static async exec(command) {

package/lib/SuiInBrowser.js

@@ -11,7 +11,7 @@ class SuiInBrowser extends SuiCommonMethods {
 
         this._adapters = {};
 
-        this._defaultChain = 'sui:devnet';
+        this._defaultChain = params.defaultChain || 'sui:devnet';
 
         this._activeAdapter = null;
         this._connectedAddress = null;

package/lib/SuiLocalTestValidator.js

@@ -1,6 +1,7 @@
 // const { spawn } = require('child_process');
 const SuiCliCommands = require('./SuiCliCommands.js');
 const SuiCommonMethods = require('./SuiCommonMethods.js');
+const { JsonRpcProvider, localnetConnection, devnetConnection } = require('@mysten/sui.js');
 
 class SuiLocalTestValidator extends SuiCommonMethods {
     constructor(params = {}) {
@@ -8,6 +9,28 @@ class SuiLocalTestValidator extends SuiCommonMethods {
 
         this._child = null;
         this._active = false;
+
+        this._testFallbackEnabled = false;
+        if (params.testFallbackEnabled) { 
+            // option for unit tests to fallback to sui:dev network in case 
+            // there is no local validator installed
+            this._testFallbackEnabled = true;
+        }
+
+        this._providerName = 'sui:localnet';
+    }
+
+    get providerName() {
+        return this._providerName;
+    }
+
+    get provider() {
+        if (this._providerName === 'sui:localnet') {
+            return new JsonRpcProvider(localnetConnection);
+        } else if (this._providerName === 'sui:devnet') {
+            // if testFallbackEnabled == true and we can't start local node
+            return new JsonRpcProvider(devnetConnection);
+        }
     }
 
     get active() {
@@ -30,13 +53,28 @@ class SuiLocalTestValidator extends SuiCommonMethods {
     }
 
     async launch() {
-        if (this._child && this._active) {
+        if (this._active) {
             return this;
         }
 
         this.log('launching sui-test-validator ...');
 
-        this._child = await SuiCliCommands.spawn('sui-test-validator', { RUST_LOG: 'consensus=off' });
+        try {
+            this._child = await SuiCliCommands.spawn('sui-test-validator', { RUST_LOG: 'consensus=off' });
+        } catch (e) {
+            if (this._testFallbackEnabled) {
+                // can't start local node. Let's switch to sui:dev
+                this.log('can not start local node. Fallback to sui:dev...');
+
+                this._child = null;
+                this._active = true;
+                this._providerName = 'sui:devnet';
+
+                return this;
+            } else {
+                throw e;
+            }
+        }
 
         this.__readyLaunchedPromiseResolver = null;
         this.__readyLaunchedPromise = new Promise((res)=>{
@@ -67,6 +105,7 @@ 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) {
@@ -34,8 +39,16 @@ class SuiMaster extends SuiCommonMethods {
         this._providerName = null;
         if (params.provider) {
             if (params.provider == 'local' || (params.provider.constructor && params.provider.constructor.name && params.provider.constructor.name == 'SuiLocalTestValidator')) {
-                this._provider = new sui.JsonRpcProvider(sui.localnetConnection);
-                this._providerName = 'sui:localnet'; 
+                if (params.provider == 'local') {
+                    this._provider = new sui.JsonRpcProvider(sui.localnetConnection);
+                    this._providerName = 'sui:localnet'; 
+                } else {
+                    // SuiLocalTestValidator
+                    this._providerName = params.provider.providerName;
+                    this._provider = params.provider.provider;
+                }
+                // this._provider = new sui.JsonRpcProvider(sui.localnetConnection);
+                // this._providerName = 'sui:localnet'; 
             } else if (params.provider == 'test' || params.provider == 'testnet') {
                 this._provider = new sui.JsonRpcProvider(sui.testnetConnection);
                 this._providerName = 'sui:testnet';
@@ -78,8 +91,6 @@ class SuiMaster extends SuiCommonMethods {
 
         this._initialized = false;
 
-        this._address = null;
-
         this._packages = {};
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "suidouble",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "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": {

package/test/sui_in_browser.test.js

@@ -0,0 +1,65 @@
+'use strict'
+
+// just a basic test of InBrowser classes. No real interaction, just structure and events
+
+const t = require('tap');
+const { test } = t;
+
+const { SuiInBrowser } = require('..');
+
+test('as single instance', async t => {
+    // probably you'd want a single instance of SuiInBrowser class on your dapp,
+    // so initialize it via class' static method:
+    const suiInBrowser = SuiInBrowser.getSingleton();
+    const suiInBrowserCopy = SuiInBrowser.getSingleton();
+
+    t.equal(suiInBrowser, suiInBrowserCopy);
+});
+
+test('initialization', async t => {
+    const suiInBrowser = new SuiInBrowser({});
+
+    t.ok(suiInBrowser);
+
+    const gotAdapters = [];
+    // it should emit 'adapter' events, even though they are not installed (remember, we are in node.js now)
+    // adapter has propery of .isInstalled
+    suiInBrowser.addEventListener('adapter', (e)=>{
+        gotAdapters.push(e.detail);
+    });
+
+    // emit is not instant, but on *nextTick*
+    await new Promise((res)=>setTimeout(res, 100));
+
+    t.ok(gotAdapters.length > 0);
+
+    const suiWalletAdapter = gotAdapters.find((adapter)=>(adapter.name == 'Sui Wallet')); // there're few, but lets test one
+
+    t.ok(suiWalletAdapter);
+
+    t.equal(suiWalletAdapter.name, 'Sui Wallet');
+    t.ok(!suiWalletAdapter.isInstalled);
+    t.ok(suiWalletAdapter.icon);
+    t.ok(suiWalletAdapter.icon.indexOf('data:image/') != -1); // icon is data-url
+
+    t.ok(suiWalletAdapter.getDownloadURL()); // url to install extension
+    t.ok(suiWalletAdapter.getDownloadURL().indexOf('https://') != -1);
+
+    // we can get instance of suiMaster out of suiInBrowser even if we are not connected to wallet
+    // it will work without signer, but you can read data from chain
+    const suiMaster = await suiInBrowser.getSuiMaster();
+
+    t.ok(suiMaster);
+    t.ok(!suiMaster.connectedAddress); // nothing
+    t.ok(suiMaster.connectedChain);     // but there's chain
+
+    // by default, SuiInBrowser gets you devnet connection (it's overloaded by Wallet Extension current chain)
+    t.equal(suiMaster.connectedChain, 'sui:devnet'); 
+
+});
+
+test('initialization via mainnet', async t => {
+    const suiInBrowser = new SuiInBrowser({defaultChain: 'sui:mainnet'});
+    const suiMaster = await suiInBrowser.getSuiMaster();
+    t.equal(suiMaster.connectedChain, 'sui:mainnet'); 
+});

package/test/sui_master_onlocal.test.js

@@ -16,7 +16,7 @@ let contractAddressV2 = null;
 let chatShopObjectId = null;
 
 test('spawn local test node', async t => {
-    suiLocalTestValidator = await SuiLocalTestValidator.launch();
+    suiLocalTestValidator = await SuiLocalTestValidator.launch({ testFallbackEnabled: true });
     t.ok(suiLocalTestValidator.active);
 
     // SuiLocalTestValidator runs as signle instance. So you can't start it twice with static method
@@ -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'});
+    suiMaster = new SuiMaster({provider: suiLocalTestValidator, as: 'somebody', debug: false});
     await suiMaster.initialize();
 
     t.ok(suiMaster.address); // there should be some address

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
+    }
+}