suidouble 0.0.6 → 0.0.8

package/index.js

@@ -1,9 +1,11 @@
 const SuiMaster = require('./lib/SuiMaster.js');
 const SuiInBrowser = require('./lib/SuiInBrowser.js');
 const SuiTestScenario = require('./lib/SuiTestScenario.js');
+const SuiLocalTestValidator = require('./lib/SuiLocalTestValidator.js');
 
 module.exports = {
     SuiMaster,
     SuiInBrowser,
     SuiTestScenario,
+    SuiLocalTestValidator,
 };

package/lib/SuiLocalTestValidator.js

@@ -10,6 +10,10 @@ class SuiLocalTestValidator extends SuiCommonMethods {
         this._active = false;
     }
 
+    get active() {
+        return this._active;
+    }
+
     static async launch(params = {}) {
         if (SuiLocalTestValidator.__instance) {
             return await SuiLocalTestValidator.__instance.launch();
@@ -27,19 +31,12 @@ class SuiLocalTestValidator extends SuiCommonMethods {
 
     async launch() {
         if (this._child && this._active) {
-            return true;
+            return this;
         }
 
         this.log('launching sui-test-validator ...');
 
         this._child = await SuiCliCommands.spawn('sui-test-validator', { RUST_LOG: 'consensus=off' });
-        
-        // spawn('sui-test-validator', [], {
-        //     env: {
-        //         ...process.env,
-        //         RUST_LOG: 'consensus=off',
-        //     }
-        // });
 
         this.__readyLaunchedPromiseResolver = null;
         this.__readyLaunchedPromise = new Promise((res)=>{

package/lib/SuiMaster.js

@@ -35,22 +35,34 @@ class SuiMaster extends SuiCommonMethods {
         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 = 'local'; 
+                this._providerName = 'sui:localnet'; 
             } else if (params.provider == 'test' || params.provider == 'testnet') {
                 this._provider = new sui.JsonRpcProvider(sui.testnetConnection);
-                this._providerName = 'test';
+                this._providerName = 'sui:testnet';
             } else if (params.provider == 'dev' || params.provider == 'devnet') {
                 this._provider = new sui.JsonRpcProvider(sui.devnetConnection);
-                this._providerName = 'dev';
+                this._providerName = 'sui:devnet';
             } else if (params.provider == 'main' || params.provider == 'mainnet') {
                 this._provider = new sui.JsonRpcProvider(sui.mainnetConnection);
-                this._providerName = 'main';
+                this._providerName = 'sui:mainnet';
 
                 this.log('we are on the mainnet, working with real money, be careful');
             } else {
                 if (params.provider && params.provider.connection && params.provider.connection.fullnode) {
                     this._provider = params.provider;
-                    this._providerName = params.provider.connection.fullnode;
+
+                    if (params.provider.connection.fullnode.indexOf('devnet') !== -1) {
+                        this._providerName = 'sui:devnet';
+                    } else if (params.provider.connection.fullnode.indexOf('testnet') !== -1) {
+                        this._providerName = 'sui:testnet';
+                    } else if (params.provider.connection.fullnode.indexOf('mainnet') !== -1) {
+                        this._providerName = 'sui:mainnet';
+                    } else if (params.provider.connection.fullnode.indexOf('127.0.0.1') !== -1) {
+                        this._providerName = 'sui:localnet';
+                    } else {
+                        // just keep provider name as unique to fullnode URL to keep separate ObjectStorage instances
+                        this._providerName = params.provider.connection.fullnode;
+                    }
                 }
             }
         }
@@ -85,6 +97,10 @@ class SuiMaster extends SuiCommonMethods {
         return this._provider;
     }
 
+    get connectedChain() {
+        return this._providerName;
+    }
+
     get address() {
         return this._address;
     }

package/package.json

@@ -1,16 +1,30 @@
 {
   "name": "suidouble",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "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": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "tap -j=1 ./test/*.test.js",
+    "coverage": "tap -j=1 ./test/*.test.js"
   },
-  "keywords": ["sui", "sui move", "move", "smart contract", "smart contracts", "sui.js", "web3", "dapps", "dapp"],
+  "keywords": [
+    "sui",
+    "sui move",
+    "move",
+    "smart contract",
+    "smart contracts",
+    "sui.js",
+    "web3",
+    "dapps",
+    "dapp"
+  ],
   "author": "Jeka Kiselyov <jeka911@gmail.com> (https://github.com/jeka-kiselyov)",
   "license": "Apache-2.0",
   "dependencies": {
     "@mysten/sui.js": "^0.34.0",
     "@wallet-standard/core": "^1.0.3"
+  },
+  "devDependencies": {
+    "tap": "^16.3.4"
   }
-}
+}

package/test/sui_master_basic.test.js

@@ -0,0 +1,62 @@
+'use strict'
+
+const t = require('tap');
+const { test } = t;
+
+const { SuiMaster } = require('..');
+
+test('initialization', async t => {
+	t.plan(2);
+
+    t.ok(true);
+    t.equal(1, 1, 'Ready state is (==1)');
+});
+
+test('pseudo-random keypairs generation works ok', async t => {
+    const suiMaster = new SuiMaster({provider: 'test', as: 'somebody'});
+    await suiMaster.initialize();
+
+    // pseudo-random generation of 'somebody' is a keypair for a wallet '0x15b9493fb639a3118fed766ca80c1da62fa20493c293f319cc7d136506d2db69'
+    // not sure if we need to assert it, as we may change pseudo-random generation algo, still keeping it function, 
+    // so lets just check we make different keypairs depending on 'as' input parameter
+    // console.log(suiMaster.address);
+
+    t.ok(suiMaster.address); // there should be some address
+    t.ok(`${suiMaster.address}`.indexOf('0x') === 0); // adress is string starting with '0x'
+
+    const suiMasterAsAdmin = new SuiMaster({provider: 'test', as: 'admin'});
+    await suiMasterAsAdmin.initialize();
+
+    t.ok(suiMasterAsAdmin.address); // there should be some address
+    t.ok(`${suiMasterAsAdmin.address}`.indexOf('0x') === 0); // adress is string starting with '0x'
+
+    t.not(`${suiMaster.address}`, `${suiMasterAsAdmin.address}`, 'different pseudo randoms should be different');
+
+    /// but if you pass the same string as 'as' - it will generate the same keypair:
+    const suiMasterAsAdminAnother =  new SuiMaster({provider: 'test', as: 'admin'});
+    await suiMasterAsAdminAnother.initialize();
+
+    t.equal(`${suiMasterAsAdminAnother.address}`, `${suiMasterAsAdmin.address}`, 'same string should generate same pseudo-random');
+});
+
+test('connecting to different chains', async t => {
+    const suiMaster = new SuiMaster({provider: 'test', as: 'somebody'});
+    await suiMaster.initialize();
+
+    t.equal(suiMaster.connectedChain, 'sui:testnet');
+
+    const suiMaster2 = new SuiMaster({provider: 'dev', as: 'somebody'});
+    await suiMaster2.initialize();
+
+    t.equal(suiMaster2.connectedChain, 'sui:devnet');
+
+    const suiMaster3 = new SuiMaster({provider: 'main', as: 'somebody'});
+    await suiMaster3.initialize();
+
+    t.equal(suiMaster3.connectedChain, 'sui:mainnet');
+
+    const suiMaster4 = new SuiMaster({provider: 'local', as: 'somebody'});
+    await suiMaster4.initialize();
+
+    t.equal(suiMaster4.connectedChain, 'sui:localnet');
+});

package/test/sui_master_onlocal.test.js

@@ -0,0 +1,39 @@
+'use strict'
+
+const t = require('tap');
+const { test } = t;
+
+const { SuiMaster, SuiLocalTestValidator } = require('..');
+
+let suiLocalTestValidator = null;
+let suiMaster = null;
+
+test('spawn local test node', async t => {
+    suiLocalTestValidator = await SuiLocalTestValidator.launch();
+    t.ok(suiLocalTestValidator.active);
+
+    // SuiLocalTestValidator runs as signle instance. So you can't start it twice with static method
+    const suiLocalTestValidatorCopy = await SuiLocalTestValidator.launch();
+    t.equal(suiLocalTestValidator, suiLocalTestValidatorCopy);
+});
+
+test('init suiMaster and connect it to local test validator', async t => {
+    suiMaster = new SuiMaster({provider: suiLocalTestValidator, as: 'somebody'});
+    await suiMaster.initialize();
+
+    t.ok(suiMaster.address); // there should be some address
+    t.ok(`${suiMaster.address}`.indexOf('0x') === 0); // adress is string starting with '0x'
+});
+
+test('request sui from faucet', async t => {
+    const balanceBefore = await suiMaster.getBalance();
+    await suiMaster.requestSuiFromFaucet();
+
+    const balanceAfter = await suiMaster.getBalance();
+
+    t.ok(balanceAfter > balanceBefore);
+});
+
+test('stops local test node', async t => {
+    SuiLocalTestValidator.stop();
+});