suidouble 0.0.44 → 0.0.46

package/index.js

@@ -3,7 +3,8 @@ const SuiInBrowser = require('./lib/SuiInBrowser.js');
 const SuiTestScenario = require('./lib/SuiTestScenario.js');
 const SuiObject = require('./lib/SuiObject.js');
 const SuiLocalTestValidator = require('./lib/SuiLocalTestValidator.js');
-const sui = require('@mysten/sui.js');
+
+const { TransactionBlock,Transactions } = require('@mysten/sui.js/transactions');
 
 module.exports = {
     SuiMaster,
@@ -13,6 +14,6 @@ module.exports = {
     SuiLocalTestValidator,
     MIST_PER_SUI: SuiMaster.MIST_PER_SUI,
 
-    TransactionBlock: sui.TransactionBlock,
-    Transactions: sui.Transactions,
+    TransactionBlock: TransactionBlock,
+    Transactions: Transactions,
 };

package/lib/SuiCliCommands.js

@@ -12,7 +12,9 @@ try {
 
     doFs = fs;
     doPath = path;
-} catch (e) {}
+} catch (e) {
+    console.log('looks we are in browser');
+}
 
 class SuiCliCommands {
     static async spawn(command, params = [], envVars = {}) {

package/lib/SuiCoin.js

@@ -66,7 +66,21 @@ class SuiCoin {
 
         const str = (''+BigInt(amount)).padStart(this.decimals + 1,'0');
         const ind = str.length - this.decimals;
-        return str.substring(0, ind) + '.' + str.substring(ind);
+        let asFloatString = str.substring(0, ind) + '.' + str.substring(ind);
+
+        /// yep, I can't find a better way to strip extra 0 at the end. All regexes are not ok. Ping me if you have a good one
+        let i = asFloatString.length - 1;
+        let haveNotMetNoZero = false;
+        while (i > 0 && !haveNotMetNoZero) {
+            if (asFloatString.substring(i, i+1) === '0' && asFloatString.substring(i-1, i) !== '.') {
+                asFloatString = asFloatString.substring(0, i);
+            } else {
+                haveNotMetNoZero = true;
+            }
+            i--;
+        }
+
+        return asFloatString;
     }
 
     get suiMaster() {

package/lib/SuiCommonMethods.js

@@ -25,7 +25,6 @@ class SuiCommonMethods extends EventTarget {
 		}
 
 		let prefix = (this._suiMaster ? (''+this._suiMaster.instanceN+' |') : (this.instanceN ? ''+this.instanceN+' |' : '') );
-		// prefix += this.constructor.name+' | ';
 
 		args.unshift(this.constructor.name+' |');
 		args.unshift(prefix);

package/lib/SuiEvent.js

@@ -1,4 +1,4 @@
-const SuiCommonMethods = require('./SuiCommonMethods.js');
+
 
 class SuiEvent extends Event {
     constructor(params = {}) {

package/lib/SuiInBrowser.js

@@ -2,7 +2,8 @@ const SuiCommonMethods = require('./SuiCommonMethods.js');
 const SuiInBrowserAdapter = require('./SuiInBrowserAdapter.js');
 const WalletsStandardCore = require('@wallet-standard/core');
 const icons = require('./data/icons.json');
-const { JsonRpcProvider } = require('@mysten/sui.js');
+const { SuiClient, getFullnodeUrl } = require('@mysten/sui.js/client');
+
 const SuiMaster = require('./SuiMaster.js');
 
 const DEFAULT_CHAIN = 'sui:devnet';
@@ -181,7 +182,7 @@ class SuiInBrowser extends SuiCommonMethods {
             throw new Error('invalid chain: '+chainName);
         }
 
-        this._provider = new JsonRpcProvider(chainSettings[chainName]);
+        this._provider = new SuiClient({url: chainSettings[chainName].fullnode});
         this._suiMaster = new SuiMaster({
             debug: this._debug,
             signer: this,

package/lib/SuiLocalTestValidator.js

@@ -1,7 +1,9 @@
 // const { spawn } = require('child_process');
 const SuiCliCommands = require('./SuiCliCommands.js');
 const SuiCommonMethods = require('./SuiCommonMethods.js');
-const { JsonRpcProvider, localnetConnection, devnetConnection } = require('@mysten/sui.js');
+// const { JsonRpcProvider, localnetConnection, devnetConnection } = require('@mysten/sui.js');
+
+const { SuiClient, getFullnodeUrl } = require('@mysten/sui.js/client');
 
 class SuiLocalTestValidator extends SuiCommonMethods {
     constructor(params = {}) {
@@ -28,10 +30,10 @@ class SuiLocalTestValidator extends SuiCommonMethods {
 
     get provider() {
         if (this._providerName === 'sui:localnet') {
-            return new JsonRpcProvider(localnetConnection);
+            return new SuiClient({url: getFullnodeUrl('localnet')});
         } else if (this._providerName === 'sui:devnet') {
             // if testFallbackEnabled == true and we can't start local node
-            return new JsonRpcProvider(devnetConnection);
+            return new SuiClient({url: getFullnodeUrl('devnet')});//JsonRpcProvider(devnetConnection);
         }
     }
 

package/lib/SuiMaster.js

@@ -1,4 +1,3 @@
-const sui = require('@mysten/sui.js');
 const SuiCommonMethods = require('./SuiCommonMethods.js');
 const SuiPackage = require('./SuiPackage.js');
 const SuiPseudoRandomAddress = require('./SuiPseudoRandomAddress.js');
@@ -8,6 +7,10 @@ const SuiObject = require('./SuiObject.js');
 const SuiTransaction = require('./SuiTransaction.js');
 const SuiEvent = require('./SuiEvent.js');
 const SuiCoins = require('./SuiCoins.js');
+const { SuiClient, getFullnodeUrl } = require('@mysten/sui.js/client');
+const { MIST_PER_SUI } = require('@mysten/sui.js/utils');
+const { Ed25519Keypair } = require('@mysten/sui.js/keypairs/ed25519');
+const { requestSuiFromFaucetV0, getFaucetHost } = require('@mysten/sui.js/faucet');
 
 class SuiMaster extends SuiCommonMethods {
     constructor(params = {}) {
@@ -31,11 +34,11 @@ class SuiMaster extends SuiCommonMethods {
             this._keypair = params.keypair;
         } else if (params.phrase) {
             if (!params.accountIndex) {
-                this._keypair = sui.Ed25519Keypair.deriveKeypair(params.phrase);
+                this._keypair = Ed25519Keypair.deriveKeypair(params.phrase);
             } else {
                 // remember you can generate many addresses with same seed?
                 const derivePath = `m/44'/784'/${params.accountIndex}'/0'/0'`;
-                this._keypair = sui.Ed25519Keypair.deriveKeypair(params.phrase, derivePath);
+                this._keypair = Ed25519Keypair.deriveKeypair(params.phrase, derivePath);
             }
 
             this.log('goint to use keypair of', this._keypair.getPublicKey().toSuiAddress());
@@ -51,7 +54,7 @@ class SuiMaster extends SuiCommonMethods {
         if (params.provider) {
             if (params.provider == 'local' || (params.provider.constructor && params.provider.constructor.name && params.provider.constructor.name == 'SuiLocalTestValidator')) {
                 if (params.provider == 'local') {
-                    this._provider = new sui.JsonRpcProvider(sui.localnetConnection);
+                    this._provider = new SuiClient({url: getFullnodeUrl('localnet')});
                     this._providerName = 'sui:localnet'; 
                 } else {
                     // SuiLocalTestValidator
@@ -61,18 +64,34 @@ class SuiMaster extends SuiCommonMethods {
                 // 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._provider = new SuiClient({url: getFullnodeUrl('testnet')});
                 this._providerName = 'sui:testnet';
             } else if (params.provider == 'dev' || params.provider == 'devnet') {
-                this._provider = new sui.JsonRpcProvider(sui.devnetConnection);
+                this._provider = new SuiClient({url: getFullnodeUrl('devnet')});
                 this._providerName = 'sui:devnet';
             } else if (params.provider == 'main' || params.provider == 'mainnet') {
-                this._provider = new sui.JsonRpcProvider(sui.mainnetConnection);
+                this._provider = new SuiClient({url: getFullnodeUrl('mainnet')});
                 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) {
+                if (params.provider && params.provider.constructor && params.provider.constructor.name && params.provider.constructor.name == 'SuiClient') {
+                    this._provider = params.provider;
+                    const url = params.provider.transport.websocketClient.endpoint;
+
+                    if (url.indexOf('devnet') !== -1) {
+                        this._providerName = 'sui:devnet';
+                    } else if (url.indexOf('testnet') !== -1) {
+                        this._providerName = 'sui:testnet';
+                    } else if (url.indexOf('mainnet') !== -1) {
+                        this._providerName = 'sui:mainnet';
+                    } else if (url.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 = url.split('//')[1];
+                    }
+                } else if (params.provider && params.provider.connection && params.provider.connection.fullnode) {
                     this._provider = params.provider;
 
                     if (params.provider.connection.fullnode.indexOf('devnet') !== -1) {
@@ -116,7 +135,7 @@ class SuiMaster extends SuiCommonMethods {
     }
 
     get MIST_PER_SUI() {
-        return BigInt(sui.MIST_PER_SUI);
+        return BigInt(MIST_PER_SUI);
     }
 
     /**
@@ -201,13 +220,18 @@ class SuiMaster extends SuiCommonMethods {
 
         // this._keypair = sui.Ed25519Keypair.deriveKeypair(this._phrase);
         if (!this._signer && this._keypair) { // we may optionally go without signer, to work in read-only mode
-            this._signer = new sui.RawSigner(this._keypair, this._provider);
+            this._signer = this._keypair;//new sui.RawSigner(this._keypair, this._provider);
         }
 
         // const publicKey = this._keypair.getPublicKey();
         // this._address = publicKey.toSuiAddress();
         if (this._signer) {
-            this._address = await this._signer.getAddress();
+            if (this._signer.toSuiAddress) {
+                this._address = this._signer.toSuiAddress();    // after Sui's refactor Keypair's method
+            } else {
+                this._address = await this._signer.getAddress(); // old method
+            }
+
             // console.log(this._signer);
             // console.log(this._providerName);
             this.log('initialized. connected as', this._address);
@@ -219,24 +243,30 @@ class SuiMaster extends SuiCommonMethods {
         return true;
     }
 
+    async signAndExecuteTransactionBlock(params) {
+        if (this._keypair) {
+            params.signer = this._keypair;
+        }
+
+        return this._provider.signAndExecuteTransactionBlock(params);
+    }
+
     async requestSuiFromFaucet() {
         await this.initialize();
 
         this.log('requesting sui from faucet...');
 
-        let res = null;
-        try {
-            res = await this._provider.requestSuiFromFaucet(this._address);
-        } catch (e) {
-            this.log('error', e);
-            res = null;
-        }
+        const faucetHost = getFaucetHost(this._providerName.split('sui:').join(''));
+        const requested = await requestSuiFromFaucetV0({
+                host: faucetHost,
+                recipient: this._address,
+            });
 
         let amount = BigInt(0);
         let objectsCount = 0;
 
-        if (res && res.transferredGasObjects) {
-            for (let transferredGasObject of res.transferredGasObjects) {
+        if (requested && requested.transferredGasObjects) {
+            for (let transferredGasObject of requested.transferredGasObjects) {
                 amount += BigInt(transferredGasObject.amount);
                 objectsCount++;
             }
@@ -266,6 +296,28 @@ class SuiMaster extends SuiCommonMethods {
         return await (suiCoin.getBalance(queryingBalanceOf));
     }
 
+    async fetchEvents(params = {}) {
+        let query = params.query;
+
+        const queryParams = {
+            descending_order: params.descending_order || false,
+            query: query,
+            limit: params.limit || 50,
+        };
+
+        const paginatedResponse = new SuiPaginatedResponse({
+            debug: this._debug,
+            suiMaster: this,
+            params: queryParams,
+            method: 'queryEvents',
+            order: params.order,
+        });
+
+        await paginatedResponse.fetch();
+
+        return paginatedResponse;
+    }
+    
     // export type TransactionFilter =
 	// | { FromOrToAddress: { addr: string } }
 	// | { Checkpoint: string }
@@ -331,6 +383,6 @@ class SuiMaster extends SuiCommonMethods {
 
 };
 
-SuiMaster.MIST_PER_SUI = BigInt(sui.MIST_PER_SUI);
+SuiMaster.MIST_PER_SUI = BigInt(MIST_PER_SUI);
 
 module.exports = SuiMaster;

package/lib/SuiObject.js

@@ -1,6 +1,6 @@
-const sui = require('@mysten/sui.js');
 const SuiCommonMethods = require('./SuiCommonMethods.js');
 const SuiPaginatedResponse = require('./SuiPaginatedResponse.js');
+const { normalizeSuiAddress } = require('@mysten/sui.js/utils');
 
 class SuiObject extends SuiCommonMethods {
     constructor(params = {}) {
@@ -41,7 +41,7 @@ class SuiObject extends SuiCommonMethods {
     }
 
     static idsEqual(id1, id2) {
-        return (sui.normalizeSuiAddress(id1) === sui.normalizeSuiAddress(id2));
+        return (normalizeSuiAddress(id1) === normalizeSuiAddress(id2));
     }
 
     get isDeleted() {
@@ -94,7 +94,7 @@ class SuiObject extends SuiCommonMethods {
         }
         
         const thisAddress = this.address;
-        if (thisAddress && thisAddress === sui.normalizeSuiAddress(toId)) {
+        if (thisAddress && thisAddress === normalizeSuiAddress(toId)) {
             return true;
         }
         return false;
@@ -102,7 +102,7 @@ class SuiObject extends SuiCommonMethods {
 
     get address() {
         try {
-            return sui.normalizeSuiAddress(this._id);
+            return normalizeSuiAddress(this._id);
         } catch (e) {
             return null;
         }

package/lib/SuiPackage.js

@@ -1,11 +1,11 @@
-const sui = require('@mysten/sui.js');
-
 const SuiCliCommands = require('./SuiCliCommands.js');
 const SuiObject = require('./SuiObject.js');
 const SuiPackageModule = require('./SuiPackageModule.js');
 const SuiPaginatedResponse = require('./SuiPaginatedResponse.js');
 
 // fromB64, toB64
+const { TransactionBlock } = require('@mysten/sui.js/transactions');
+const { normalizeSuiAddress } = require('@mysten/sui.js/utils');
 
 class SuiPackage extends SuiObject {
     constructor(params = {}) {
@@ -345,7 +345,7 @@ class SuiPackage extends SuiObject {
         if (result && result.objectChanges && result.objectChanges.length) {
             for (const objectChange of result.objectChanges) {
                 if (objectChange.type === 'published' && objectChange.packageId) {
-                    this._id = sui.normalizeSuiAddress(objectChange.packageId);
+                    this._id = normalizeSuiAddress(objectChange.packageId);
                     this._isPublished = true;
 
                     if (objectChange.version) {
@@ -398,7 +398,7 @@ class SuiPackage extends SuiObject {
 
         this.log('publishing package...');
 
-        const tx = new sui.TransactionBlock();
+        const tx = new TransactionBlock();
         const [upgradeCap] = tx.publish({
             modules: this._builtModules,
             dependencies: this._builtDependencies,
@@ -406,7 +406,7 @@ class SuiPackage extends SuiObject {
 
         tx.transferObjects([upgradeCap], tx.pure(this._suiMaster.address));
 
-        const result = await this._suiMaster.signer.signAndExecuteTransactionBlock({
+        const result = await this._suiMaster.signAndExecuteTransactionBlock({
             transactionBlock: tx,
             requestType: 'WaitForLocalExecution',
             options: {
@@ -434,7 +434,7 @@ class SuiPackage extends SuiObject {
 
         this.log('upgrading package...');
 
-        const tx = new sui.TransactionBlock();
+        const tx = new TransactionBlock();
 
         const cap = tx.object(await this.getUpgradeCapId());
         // export enum UpgradePolicy {
@@ -461,7 +461,7 @@ class SuiPackage extends SuiObject {
             arguments: [cap, receipt],
         });
 
-        const result = await this._suiMaster.signer.signAndExecuteTransactionBlock({
+        const result = await this._suiMaster.signAndExecuteTransactionBlock({
             transactionBlock: tx,
             options: {
                 showEffects: true,

package/lib/SuiPackageModule.js

@@ -1,4 +1,3 @@
-const sui = require('@mysten/sui.js');
 const SuiObject = require('./SuiObject.js');
 
 const SuiCommonMethods = require('./SuiCommonMethods.js');
@@ -6,6 +5,9 @@ const SuiPaginatedResponse = require('./SuiPaginatedResponse.js');
 const SuiEvent = require('./SuiEvent.js');
 // fromB64, toB64
 
+const { TransactionBlock } = require('@mysten/sui.js/transactions');
+const { normalizeSuiAddress } = require('@mysten/sui.js/utils');
+
 class SuiPackageModule extends SuiCommonMethods {
     constructor(params = {}) {
         super(params);
@@ -88,7 +90,7 @@ class SuiPackageModule extends SuiCommonMethods {
             address = suiObjectOrAddress.address;
         }
         try {
-            address = sui.normalizeSuiAddress(address);
+            address = normalizeSuiAddress(address);
             if (!this.objectStorage.byAddress(address)) {
                 if (suiObjectOrAddress.address) {
                     // instance of suiObject
@@ -119,7 +121,7 @@ class SuiPackageModule extends SuiCommonMethods {
         if (params.tx) {
             tx = params.tx;
         } else {
-            tx = new sui.TransactionBlock();
+            tx = new TransactionBlock();
 
             const callArgs = [];
     
@@ -150,7 +152,7 @@ class SuiPackageModule extends SuiCommonMethods {
             });
         }
 
-        const result = await this._suiMaster._signer.signAndExecuteTransactionBlock({
+        const result = await this._suiMaster.signAndExecuteTransactionBlock({
             transactionBlock: tx,
             requestType: 'WaitForLocalExecution',
             options: {

package/lib/SuiPaginatedResponse.js

@@ -1,4 +1,3 @@
-const sui = require('@mysten/sui.js');
 const SuiCommonMethods = require('./SuiCommonMethods.js');
 const SuiEvent = require('./SuiEvent.js');
 const SuiTransaction = require('./SuiTransaction.js');

package/lib/SuiPseudoRandomAddress.js

@@ -1,6 +1,6 @@
 const { entropyToMnemonic } = require('@scure/bip39');
 const { wordlist } = require('@scure/bip39/wordlists/english');
-const { Ed25519Keypair } = require('@mysten/sui.js');
+const { Ed25519Keypair } = require('@mysten/sui.js/keypairs/ed25519');
 
 class SuiPseudoRandomAddress {
     static stringToKeyPair(as) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "suidouble",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "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/coins.test.js

@@ -0,0 +1,111 @@
+'use strict'
+
+const t = require('tap');
+const { test } = t;
+
+const { SuiMaster, SuiLocalTestValidator, TransactionBlock } = require('..');
+
+let suiLocalTestValidator = null;
+let suiMaster = null;
+
+test('spawn local test node', async t => {
+    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
+    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: 'local', as: 'somebody', debug: true});
+    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('type is normalized for SUI', async t => {
+    // eveything should be the same:
+    const suiCoin1 = suiMaster.suiCoins.get('sui');
+    const suiCoin2 = suiMaster.suiCoins.get('SUI');
+    const suiCoin3 = suiMaster.suiCoins.get('0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI');
+    const suiCoin4 = suiMaster.suiCoins.get('0x2::sui::SUI');
+    const suiCoin5 = suiMaster.suiCoins.get('2::sui::SUI');
+    const suiCoin6 = suiMaster.suiCoins.get('0000000000000000000000000000000000000000000000000000000000000002::sui::SUI');
+
+    t.ok(suiCoin1.coinType == suiCoin2.coinType);
+    t.ok(suiCoin1.coinType == suiCoin3.coinType);
+    t.ok(suiCoin1.coinType == suiCoin4.coinType);
+    t.ok(suiCoin1.coinType == suiCoin5.coinType);
+    t.ok(suiCoin1.coinType == suiCoin6.coinType);
+
+    // moreover, it should be the same instance
+    t.ok(Object.keys(suiMaster.suiCoins.coins).length == 1);
+});
+
+test('amount normalization works ok', async t => {
+    const suiCoin = suiMaster.suiCoins.get('sui');
+    t.ok((await suiCoin.lazyNormalizeAmount('1.0')) == suiMaster.MIST_PER_SUI); // lazy - loads metadata to get decimals
+    t.ok((await suiCoin.lazyNormalizeAmount(suiMaster.MIST_PER_SUI)) == suiMaster.MIST_PER_SUI); // can pass BigInt
+    t.ok((await suiCoin.lazyNormalizeAmount(Number(suiMaster.MIST_PER_SUI))) == suiMaster.MIST_PER_SUI); // can pass Number, it will return BigInt of if
+});
+
+test('string representation works ok', async t => {
+    const suiCoin = suiMaster.suiCoins.get('sui');
+    await suiCoin.getMetadata();
+
+    const toDisplay1 = suiCoin.amountToString(suiMaster.MIST_PER_SUI);
+    t.equals(toDisplay1, '1.0');
+
+    const toDisplay2 = suiCoin.amountToString(1); // 1 mist
+    t.equals(toDisplay2, '0.000000001');
+
+    const toDisplay3 = suiCoin.amountToString(suiMaster.MIST_PER_SUI * BigInt(1000) + BigInt(1)); // 1000 SUI + 1 mist
+    t.equals(toDisplay3, '1000.000000001');
+
+    const toDisplay4 = suiCoin.amountToString(suiMaster.MIST_PER_SUI * BigInt(1000) - BigInt(1)); // 1000 SUI - 1 mist
+    t.equals(toDisplay4, '999.999999999');
+});
+
+test('you have no SUI on the fresh node', async t => {
+    const suiCoin = suiMaster.suiCoins.get('sui');
+    const balance = await suiCoin.getBalance(suiMaster.address);
+    t.ok(balance == BigInt(0));
+});
+
+test('have some after requesting from faucet', async t => {
+    await suiMaster.requestSuiFromFaucet();
+
+    const suiCoin = suiMaster.suiCoins.get('sui');
+    const balance = await suiCoin.getBalance(suiMaster.address);
+    t.ok(balance > BigInt(0));
+});
+
+test('getting coin objects for a transaction', async t => {
+    const suiCoin = suiMaster.suiCoins.get('sui');
+
+    const wasBalance = await suiCoin.getBalance(suiMaster.address);
+
+    const txb = new TransactionBlock();
+    const coinInput = await suiCoin.coinOfAmountToTxCoin(txb, suiMaster.address, suiMaster.MIST_PER_SUI); // pick 1 SUI
+    txb.transferObjects([coinInput], txb.pure('0x1d20dcdb2bca4f508ea9613994683eb4e76e9c4ed371169677c1be02aaf0b12a')); // send it anywhere
+
+    const result = await suiMaster.signAndExecuteTransactionBlock({
+        transactionBlock: txb,
+        requestType: 'WaitForLocalExecution',
+        options: {
+        },
+    });
+
+    const nowBalance = await suiCoin.getBalance(suiMaster.address);
+
+    t.ok(nowBalance < wasBalance);  /// would be better to calculate everthing + fees + storage rebate, but let's just assume it works for now.
+    // @todo : cover better
+});
+
+
+
+test('stops local test node', async t => {
+    await SuiLocalTestValidator.stop();
+});