suidouble 1.0.4 → 1.6.0-1

package/README.md

@@ -168,7 +168,9 @@ while (events.hasNextPage) {
 
 ##### subscribing to events
 
-You can subscribe to Sui's contract events on package's module level. No types-etc filters for now ( @todo? )
+*** Subscribe to Events is deprecated in Sui SDK *** You should plan to use different architecture in your application.
+
+You can subscribe to Sui's contract events on package's module level. 
 
 ```javascript
 const module = await contract.getModule('suidouble_chat');
@@ -228,7 +230,7 @@ arguments.push(contract.arg('u128', 5555));
 arguments.push(contract.arg('u256', 6666));
 arguments.push(contract.arg('address', '0xd9a95d7cc137f71dd7766f02791536453062a7509e9f461620cc4f583b09134c'));
 arguments.push(contract.arg('string', 'some utf-8 💧string'));
-arguments.push(contract.arg('vector<u8>', 222)); // works for other vectors with primitive contents, e.g. u128, bool etc
+arguments.push(contract.arg('vector<u8>', [222,111,211])); // works for other vectors with primitive contents, e.g. u128, bool etc
 ```
 
 Take a look at unit test covering all types arguments [here](test/different_types_args.test.js)
@@ -292,20 +294,21 @@ Don't forget to test transactions sending real money on devnet/testnet first!
 
 ##### composing transaction block yourself
 
-If you need more flexebility, there's always an option to construct the transaction block yourself:
+If you need more flexebility, there's always an option to construct the transaction yourself:
 
 ```javascript
-const { TransactionBlock, Transactions } = require('suidobule'); // this exposes classes from the "@mysten/sui.js", so you don't have to import them separately
+const { Transaction, txInput } = require('suidobule'); // this exposes classes from the "@mysten/sui.js", so you don't have to import them separately
 
-const txb = new TransactionBlock();
-txb.moveCall({
+const tx = new Transaction();
+tx.moveCall({
     target: `package_id::module_id::method_name`,
     arguments: [
-        txb.pure(contract.arg('u256', something)),
-        txb.object(someid),
+        txInput(tx, 'u256', some_value),
+        txInput(tx, 'vector<bool>', some_array),
+        tx.object('0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c'), // object ids are ok t
     ],
 });
-const moveCallResult = await contract.moveCall('suidouble_chat', 'post_pay', {tx: txb});
+const moveCallResult = await contract.moveCall('suidouble_chat', 'post_pay', {tx: tx});
 ```
 
 

package/index.js

@@ -5,6 +5,7 @@ const SuiObject = require('./lib/SuiObject.js');
 const SuiUtils = require('./lib/SuiUtils.js');
 const SuiLocalTestValidator = require('./lib/SuiLocalTestValidator.js');
 const { Transaction, Commands } = require('@mysten/sui/transactions');
+const { bcs } = require('@mysten/sui/bcs');
 
 module.exports = {
     SuiMaster,
@@ -16,4 +17,6 @@ module.exports = {
     Transaction: Transaction,
     Commands: Commands,
     SuiUtils: SuiUtils,
+    txInput: SuiUtils.txInput,
+    bcs,
 };

package/lib/SuiCoin.js

@@ -1,6 +1,5 @@
-const { Commands } = require('@mysten/sui/transactions');
+const { Commands, Transaction, TransactionObjectArgument } = require('@mysten/sui/transactions');
 const { bcs } = require('@mysten/sui/bcs');
-// console.log(bcs);
 
 
 const safeList = {
@@ -25,7 +24,15 @@ const safeList = {
     },
 };
 
+/** Coin metadata object */
 class SuiCoin {
+
+    /**
+     * SuiCoin constructor
+     * @param {Object} params - Initialization parameters
+     * @param {string} params.coinType - sui object type for a coin, without Coin<...>, only the inside type
+     * @param {SuiCoins} params.suiCoins - instance of SuiCoins
+     */
     constructor(params = {}) {
         this._coinType = params.coinType;
         this._suiCoins = params.suiCoins;
@@ -102,6 +109,15 @@ class SuiCoin {
         return '0x'+this._coinType;
     }
 
+    /**
+     * Move type for the Coin object of this coin type
+     * 
+     * @type {string}
+     */
+    get coinObjectType() {
+        return '0x2::coin::Coin<'+this.coinType+'>';
+    }
+
     get decimals() {
         if (this.metadata) {
             return this.metadata.decimals;
@@ -202,6 +218,15 @@ class SuiCoin {
         return totalAmount;
     }
 
+    /**
+     * Returns TransactionObjectArgument with Coin of amount to be used in tranasctions
+     * 
+     * @param {Transaction} txb - Native SUI SDK Transaction
+     * @param {string} owner - address of the owner
+     * @param {BigInt|string} amount - amount of coin. BigIng or String to be normalized via Coin decimals, "0.05" for 0.05 sui
+     * @param {boolean} addEmptyCoins - attach coins == 0 to the list
+     * @returns {TransactionObjectArgument}
+     */
     async coinOfAmountToTxCoin(txb, owner, amount, addEmptyCoins = false) {
         const normalizedAmount = await this.lazyNormalizeAmount(amount);
 
@@ -215,12 +240,6 @@ class SuiCoin {
         if (coinIds.length == 1) {
             // only one coin object enough to cover the expense
             if (this.isSUI()) {
-                // console.log(txb.gas);
-                // console.log(bcs);
-                // console.log(txb.pure(bcs.vector(bcs.u64).serialize([expectedAmountAsBigInt])));
-                // console.log(txb.pure.u64(expectedAmountAsBigInt));
-                // txb.pure(bcs.vector(bcs.u64).serialize(['0x123']))
-
                 const coinInput = txb.add(Commands.SplitCoins(txb.gas, [txb.pure.u64(expectedAmountAsBigInt)]));
                 return coinInput;
             } else {

package/lib/SuiCoins.js

@@ -97,6 +97,12 @@ class SuiCoins extends SuiCommonMethods {
         return coinType;
     }
 
+    /**
+     * Return instance of SuiCoin of specific type
+     * 
+     * @param {string} coinType - MoveType, or 'SUI' as helper
+     * @returns {SuiCoin}
+     */
     get(coinType) {
         const normalizedCoinType = this.normalizeCoinType(coinType); 
         let suiCoin = this._coins[normalizedCoinType];

package/lib/SuiInBrowser.js

@@ -42,6 +42,10 @@ class SuiInBrowser extends SuiCommonMethods {
         return await this._activeAdapter.signAndExecuteTransactionBlock(params);
     }
 
+    async signAndExecuteTransaction(params) {
+        return await this._activeAdapter.signAndExecuteTransaction(params);
+    }
+
     get client() {
         return this._client;
     }

package/lib/SuiInBrowserAdapter.js

@@ -8,6 +8,8 @@ const Feature = {
     EVENTS: 'standard:events',
     SUI_SIGN_AND_EXECUTE_TX_BLOCK: 'sui:signAndExecuteTransactionBlock',
     SUI_SIGN_TX_BLOCK: 'sui:signTransactionBlock',
+    SUI_SIGN_AND_EXECUTE_TX: 'sui:signAndExecuteTransaction',
+    SUI_SIGN_TX: 'sui:signTransaction',
     SUI_SIGN_MESSAGE: 'sui:signMessage'
 };
 
@@ -30,10 +32,30 @@ class SuiInBrowserAdapter extends SuiCommonMethods {
         this._isConnected = false;
     }
 
+    async signAndExecuteTransaction(params) {
+        if (this.hasFeature(Feature.SUI_SIGN_AND_EXECUTE_TX)) {
+            return await this.getFeature(Feature.SUI_SIGN_AND_EXECUTE_TX).signAndExecuteTransaction(params);
+        } else {
+            // outdated wallet?
+            params.transactionBlock = params.transaction;
+            return await this.getFeature(Feature.SUI_SIGN_AND_EXECUTE_TX_BLOCK).signAndExecuteTransactionBlock(params);
+        }
+    }
+
     async signAndExecuteTransactionBlock(params) {
         return await this.getFeature(Feature.SUI_SIGN_AND_EXECUTE_TX_BLOCK).signAndExecuteTransactionBlock(params);
     }
 
+    async signTransactionBlock(params) {
+        if (this.hasFeature(Feature.SUI_SIGN_TX)) {
+            return await this.getFeature(Feature.SUI_SIGN_TX).signTransaction(params);
+        } else {
+            // outdated wallet?
+            params.transactionBlock = params.transaction;
+            return await this.getFeature(Feature.SUI_SIGN_TX_BLOCK).signTransactionBlock(params);
+        }
+    }
+
     async signTransactionBlock(params) {
         return await this.getFeature(Feature.SUI_SIGN_TX_BLOCK).signTransactionBlock(params);
     }

package/lib/SuiLocalTestValidator.js

@@ -1,7 +1,6 @@
-// const { spawn } = require('child_process');
+const net = require("net");
 const SuiCliCommands = require('./SuiCliCommands.js');
 const SuiCommonMethods = require('./SuiCommonMethods.js');
-// const { JsonRpcProvider, localnetConnection, devnetConnection } = require('@mysten/sui.js');
 
 const { SuiClient, getFullnodeUrl, SuiHTTPTransport } = require('@mysten/sui/client');
 const SuiUtils = require('./SuiUtils.js');
@@ -65,6 +64,51 @@ class SuiLocalTestValidator extends SuiCommonMethods {
         }
     }
 
+    async isPortThere(port) {
+        const Socket = net.Socket;
+        const socket = new Socket();
+
+        let __waitPortPromiseResolver = null;
+        const __waitPortPromise = new Promise((res)=>{ __waitPortPromiseResolver = res; });
+
+        setTimeout(()=>{
+            socket.destroy();
+            __waitPortPromiseResolver(false);
+        }, 3000);
+        socket.on("connect", () => {
+            __waitPortPromiseResolver(true);
+        });
+        socket.on("error", () =>
+        {
+            __waitPortPromiseResolver(false);
+        });
+        socket.on("timeout", () => {
+            __waitPortPromiseResolver(false);
+        });
+
+        socket.connect(port, "0.0.0.0");
+
+        const portIsThere = await __waitPortPromise;
+        socket.destroy();
+
+        return portIsThere;
+    }
+
+    async waitForPort(port, timeout) {
+        this.log('waiting for port', port);
+        const startedCheckingAt = (new Date()).getTime();
+        let portIsThere = false;
+        do {
+            portIsThere = await this.isPortThere(port);
+            this.log('checking for port', port, 'is there:', portIsThere);
+            if (!portIsThere) {
+                await new Promise((res)=>setTimeout(res, 500));
+            }
+        } while (!portIsThere && (startedCheckingAt + timeout) > ((new Date()).getTime()));
+
+        return portIsThere;
+    }
+
     async launch() {
         if (this._active) {
             return this;
@@ -73,12 +117,22 @@ class SuiLocalTestValidator extends SuiCommonMethods {
         this.log('launching sui-test-validator ...');
 
         try {
-            const params = [];
-            if (this._epochDuration) {
-                params.push('--epoch-duration-ms');
-                params.push(this._epochDuration);
+            try {
+                // try sui-test-validator
+                const params = [];
+                if (this._epochDuration) {
+                    params.push('--epoch-duration-ms');
+                    params.push(this._epochDuration);
+                }
+                this._child = await SuiCliCommands.spawn('sui-test-validator', params, { RUST_LOG: 'consensus=off' });
+            } catch (e) {
+                this.log('can not launch sui-test-validator. Trying to run "sui start"...');
+                const params = [];
+                params.push('start');
+                params.push('--with-faucet');
+                params.push('--force-regenesis');
+                this._child = await SuiCliCommands.spawn('sui', params, { RUST_LOG: 'off,sui_node=info' });
             }
-            this._child = await SuiCliCommands.spawn('sui-test-validator', params, { RUST_LOG: 'consensus=off' });
         } catch (e) {
             if (this._testFallbackEnabled) {
                 // can't start local node. Let's switch to sui:dev
@@ -93,29 +147,6 @@ class SuiLocalTestValidator extends SuiCommonMethods {
                 throw e;
             }
         }
-
-        this.__readyLaunchedPromiseResolver = null;
-        this.__readyLaunchedPromise = new Promise((res)=>{
-            this.__readyLaunchedPromiseResolver = res;
-        });
-
-        this._child.stdout.on('data', (data) => {
-            this.log(`stdout:\n${data}`);
-            if ((`${data}`).indexOf('Fullnode RPC URL') !== -1) {
-                this._active = true;
-
-                this.log('sui-test-validator launched');
-                this.__readyLaunchedPromiseResolver();
-            }
-        });
-        
-        this._child.stderr.on('data', (data) => {
-            this.log(`stderr: ${data}`);
-        });
-        
-        this._child.on('error', (error) => {
-            this.log(`error: ${error.message}`);
-        });
         
         this._child.on('close', (code) => {
             this._active = false;
@@ -131,7 +162,9 @@ class SuiLocalTestValidator extends SuiCommonMethods {
         process.on('SIGINT', cleanExit); // catch ctrl-c
         process.on('SIGTERM', cleanExit); // catch kill
 
-        await this.__readyLaunchedPromise;
+        this._active = await this.waitForPort(9123, 30000);
+
+        // await this.__readyLaunchedPromise;
 
         return this;
     }

package/lib/SuiMaster.js

@@ -102,6 +102,11 @@ class SuiMaster extends SuiCommonMethods {
         return SuiUtils;
     }
 
+    /**
+     * Instance of SuiCoins class connected to this SuiMaster
+     * 
+     * @type {SuiCoins}
+     */
     get suiCoins() {
         return this._suiCoins;
     }
@@ -110,12 +115,8 @@ class SuiMaster extends SuiCommonMethods {
         return BigInt(MIST_PER_SUI);
     }
 
-    get TransactionBlock() {
-        return TransactionBlock;
-    }
-
-    get Transactions() {
-        return Transactions;
+    get Transaction() {
+        return Transaction;
     }
 
     get Commands() {

package/lib/SuiPackage.js

@@ -452,8 +452,8 @@ class SuiPackage extends SuiObject {
 
         const authorizeUpgradeArguments = [
             cap,
-            tx.pure(this.arg('u8', UpgradePolicyCOMPATIBLE)), 
-            tx.pure(this.arg('vector<u8>', this._builtDigest)),
+            this._suiMaster.utils.txInput(tx, 'u8', UpgradePolicyCOMPATIBLE), 
+            this._suiMaster.utils.txInput(tx, 'vector<u8>', this._builtDigest), 
         ];
 
         const ticket = tx.moveCall({

package/lib/SuiPackageModule.js

@@ -7,8 +7,18 @@ const SuiEvent = require('./SuiEvent.js');
 
 const { Transaction } = require('@mysten/sui/transactions');
 const { normalizeSuiAddress } = require('@mysten/sui/utils');
+const SuiMaster = require('./SuiMaster.js');
+const SuiPackage = require('./SuiPackage.js');
 
 class SuiPackageModule extends SuiCommonMethods {
+    
+    /**
+     * SuiPackageModule constructor
+     * @param {Object} params - Initialization parameters
+     * @param {SuiPackage} params.package - instance of SuiPackage this module is part of
+     * @param {SuiMaster} params.suiMaster - instance of SuiMaster
+     * @param {string} params.moduleName - name of the Move module
+     */
     constructor(params = {}) {
         super(params);
 
@@ -16,6 +26,7 @@ class SuiPackageModule extends SuiCommonMethods {
         if (!this._package) {
             throw new Error('package is required for SuiPackageModule');
         }
+
         this._suiMaster = params.suiMaster;
         if (!this._suiMaster) {
             throw new Error('suiMaster is requried for SuiPackageModule');
@@ -25,9 +36,6 @@ class SuiPackageModule extends SuiCommonMethods {
             throw new Error('moduleName is required for SuiPackageModule');
         }
 
-        // this._objects = {};
-        // this._objectsArray = [];
-
         // 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 = {};
@@ -154,10 +162,15 @@ class SuiPackageModule extends SuiCommonMethods {
                     // vector<Coin<SUI>>
                     const ownerAddress = this._suiMaster.address;
 
-                    const suiCoin = await this._suiMaster.suiCoins.get(param.type);
-                    const txCoinToSend = await suiCoin.coinOfAmountToTxCoin(tx, ownerAddress, param.amount);
+                    const suiCoin = await this._suiMaster.suiCoins.get(param[0].type);
+                    const txCoinToSend = await suiCoin.coinOfAmountToTxCoin(tx, ownerAddress, param[0].amount);
 
-                    callArgs.push(tx.makeMoveVec({ objects: [txCoinToSend]}));
+                    callArgs.push(tx.makeMoveVec({ type: suiCoin.coinObjectType, elements: [txCoinToSend]}));
+                } else if (typeof param === 'string' && param.indexOf('0x') === 0) {
+                    callArgs.push(tx.object(param));
+                } else if (param && param.Pure && param.Pure.bytes) {
+                    // already Pure
+                    callArgs.push(this._suiMaster.utils.txInput(tx, param));
                 } else {
                     callArgs.push(tx.pure(param));
                 }

package/lib/SuiUtils.js

@@ -1,13 +1,32 @@
 const SuiCommonMethods = require('./SuiCommonMethods.js');
-const { Inputs } = require('@mysten/sui/transactions');
+const { Inputs, Transaction, Argument } = require('@mysten/sui/transactions');
 const { bcs } = require('@mysten/sui/bcs');
+const { fromB64 } = require('@mysten/bcs');
 const { SuiClient, getFullnodeUrl, SuiHTTPTransport } = require('@mysten/sui/client');
 const { normalizeSuiAddress } = require('@mysten/sui/utils');
 
 const WebSocketClient = require('websocket').w3cwebsocket;
 
+/** Helpful methods using in different places of suidouble */
 class SuiUtils extends SuiCommonMethods {
 
+    /**
+     * Attach the parameter input into transaction, to be used for moveCall
+     * accepts an Inputs.Pure (result of .pureInput) or type + value directly
+     * 
+     * @param {Transaction} tx 
+     * @param {string | Inputs.Pure} typeOrInput 
+     * @param {?Argument} value 
+     * @returns Argument
+     */
+    static txInput(tx, typeOrInput, value = null) {
+        if (typeOrInput && typeOrInput.Pure && typeOrInput.Pure.bytes) {
+            return tx.pure(SuiUtils.pureInputToBytes(typeOrInput));
+        } else {
+            return tx.pure(SuiUtils.pureInputToBytes(SuiUtils.pureInput(typeOrInput, value)));
+        }
+    }
+
     /**
      * Returns and Inputs.Pure for a given type
      *   to be used as moveCall parameters
@@ -19,13 +38,7 @@ class SuiUtils extends SuiCommonMethods {
      *         SuiUtils.pureInput('string', 'metadata')
      *     ]);
      * 
-     *  or:
-     *   wrapped in tx.pure if you are going to construct tx yourself:
-     *    const tx = new Transaction();
-     *    tx.moveCall({ target: `x.x.x`, arguments: [
-     *         tx.pure(SuiUtils.pureInput('u8',22)),
-     *         tx.pure(SuiUtils.pureInput('string','test')),
-     *      ] });
+     * if you are going to construct tx yourself, you'd better use SuiUtils.txInput static method
      * 
      * @param {string} type 
      * @param {value} value 
@@ -58,24 +71,34 @@ class SuiUtils extends SuiCommonMethods {
         }
     }
 
+    /**
+     * Convert sui's PureInput into bcs serialized bytes
+     * @param {Inputs.Pure} pureInput 
+     */
+    static pureInputToBytes(pureInput) {
+        return fromB64(pureInput.Pure.bytes);
+    }
+
     /**
      * Wrapper for sui's utils normalizeSuiAddress
      * Perform the following operations:
+     * <pre>
      * 1. Make the address lower case
      * 2. Prepend `0x` if the string does not start with `0x`.
      * 3. Add more zeros if the length of the address(excluding `0x`) is less than `SUI_ADDRESS_LENGTH`
+     * </pre>
      *
      * @param {string} address 
      * @returns string
      */
-    normalizeSuiAddress(address) {
+    static normalizeSuiAddress(address) {
         return normalizeSuiAddress(address);
     }
 
     /**
      * As SUI removed websocket dependency for a node, we'll have it here as constructor wrapper
      *   returning native WebSocket in browser and websocket's w3cwebsocket in node
-     * @returns 
+     * @returns WebSocketClient
      */
     static WebSocketConstructor() {
         return WebSocketClient;
@@ -128,7 +151,7 @@ class SuiUtils extends SuiCommonMethods {
                 client = SuiUtils.suiClientFor('mainnet');
                 providerName = 'sui:mainnet';
             } else {
-                if (clientParam && clientParam.constructor && clientParam.constructor.name && clientParam.constructor.name == 'SuiClient') {
+                if (clientParam && clientParam.constructor && (clientParam.endpoint || clientParam.transport)) {
                     client = clientParam;
                     let url = '';
                     if (clientParam.endpoint) {

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "suidouble",
-  "version": "1.0.4",
+  "version": "1.6.0-1",
   "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": "tap -j=1 ./test/*.test.js",
-    "coverage": "tap -j=1 ./test/*.test.js"
+    "test": "tap -j1 -t120 ./test/*.test.js",
+    "coverage": "tap -j1 -t120 ./test/*.test.js"
   },
   "keywords": [
     "sui",
@@ -21,17 +21,18 @@
   "author": "Jeka Kiselyov <jeka911@gmail.com> (https://github.com/jeka-kiselyov)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@mysten/sui": "^1.0.4",
+    "@mysten/sui": "^1.6.0",
     "@wallet-standard/core": "^1.0.3",
     "websocket": "^1.0.35"
   },
   "devDependencies": {
-    "tap": "^16.3.4"
+    "tap": "^21.0.1"
+  },
+  "browser": {
+    "child_process": false,
+    "fs": false,
+    "path": false
   },
   "tap": {
-    "branches": 90,
-    "lines": 90,
-    "functions": 90,
-    "statements": 90
   }
 }

package/test/coins.test.js

@@ -89,7 +89,7 @@ test('getting coin objects for a transaction', async t => {
 
     const tx = new Transaction();
     const coinInput = await suiCoin.coinOfAmountToTxCoin(tx, suiMaster.address, suiMaster.MIST_PER_SUI); // pick 1 SUI
-    tx.transferObjects([coinInput], tx.pure('0x1d20dcdb2bca4f508ea9613994683eb4e76e9c4ed371169677c1be02aaf0b12a')); // send it anywhere
+    tx.transferObjects([coinInput], '0x1d20dcdb2bca4f508ea9613994683eb4e76e9c4ed371169677c1be02aaf0b12a'); // send it anywhere
 
     const result = await suiMaster.signAndExecuteTransaction({
         transaction: tx,

package/test/sui_master_onlocal.test.js

@@ -152,33 +152,36 @@ 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();
+// Event websocket subscriptions are going to be deprecated.
+// test('subscribe to module events', async t => {
+//     const module = await contract.getModule('suidouble_chat');
+//     await module.subscribeEvents();
 
-    let gotEventChatTopMessageCreated = false;
-    let gotEventChatResponseCreated = false;
+//     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
-    });
+//     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, contract.arg('string', 'the message'), contract.arg('string', 'metadata')]);
-    await new Promise((res)=>setTimeout(res, 300)); // got events without timeout, but just to be sure.
+//     await contract.moveCall('suidouble_chat', 'post', [chatShopObjectId, contract.arg('string', 'the message'), contract.arg('string', 'metadata')]);
+//     await new Promise((res)=>setTimeout(res, 300)); // got events without timeout, but just to be sure.
 
-    t.ok(gotEventChatTopMessageCreated);
-    t.ok(gotEventChatResponseCreated);
+//     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);
+//     // 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();
-});
+//     // unsubscribing from events, to close websocket
+//     await module.unsubscribeEvents();
+
+//     t.end();
+// });
 
 test('execute contract methods', async t => {
     const moveCallResult = await contract.moveCall('suidouble_chat', 'post', [chatShopObjectId, contract.arg('string', 'the message'), contract.arg('string', 'metadata')]);
@@ -346,9 +349,7 @@ test('testing move call with coins', async t => {
 
     t.ok(foundChatTopMessage);
     t.ok(foundChatResponse);
-    
-    // messageTextAsBytes = [].slice.call(new TextEncoder().encode(messageText)); // regular array with utf data
-    // suidouble_chat contract store text a bytes (easier to work with unicode things), let's convert it back to js string
+
     foundText = new TextDecoder().decode(new Uint8Array(foundText));
 
     t.equal(foundText, longMessageYouCanNotPostForFree);
@@ -358,6 +359,19 @@ test('testing move call with coins', async t => {
     t.ok( balanceNow <= (balanceWas - 400000000000n) );
 });
 
+test('testing move call with vector<Coin<..>>', async t => {
+    const balanceWas = await suiMaster.getBalance();
+    const longMessageYouCanNotPostForFree = ('message ').padEnd(500, 'test');
+
+    // you can pass vector of coin, wrapping it's definition in array
+    const moveCallResult = await contract.moveCall('suidouble_chat', 'post_pay_with_coin_vector', [chatShopObjectId, [{type: 'SUI', amount: 400000000000n}], contract.arg('string', longMessageYouCanNotPostForFree), contract.arg('string', 'metadata')]);
+    // it's the wrapper over the same move function we've already tested, so lets keep the unit simple:
+    t.ok(moveCallResult.created.length > 0);
+
+    const balanceNow = await suiMaster.getBalance();
+    t.ok( balanceNow <= (balanceWas - 400000000000n) ); // vector<Coin<SUI>> paid
+});
+
 test('testing move call deleting object', async t => {
 
     console.error('chatResponseToDelete', chatResponseToDelete);

package/test/test_move_contracts/different_types/Move.lock

@@ -21,6 +21,6 @@ dependencies = [
 ]
 
 [move.toolchain-version]
-compiler-version = "1.25.1"
+compiler-version = "1.30.1"
 edition = "2024.beta"
 flavor = "sui"

package/test/test_move_contracts/suidouble_chat/Move.lock

@@ -22,6 +22,6 @@ dependencies = [
 ]
 
 [move.toolchain-version]
-compiler-version = "1.25.1"
-edition = "legacy"
+compiler-version = "1.30.1"
+edition = "2024.beta"
 flavor = "sui"

package/test/test_move_contracts/suidouble_chat/sources/suidouble_chat.move

@@ -3,7 +3,7 @@ module suidouble_chat::suidouble_chat {
     use sui::object::{Self, UID, ID};
     use sui::transfer;
     use sui::tx_context::{Self, TxContext};
-    use std::vector::length;
+    use std::vector::{Self, length};
 
     use sui::dynamic_object_field::{Self};
 
@@ -12,6 +12,7 @@ module suidouble_chat::suidouble_chat {
     use sui::balance::{Self, Balance};
     
     use std::debug;
+    use sui::pay;
 
     use sui::event::emit;
 
@@ -168,6 +169,17 @@ module suidouble_chat::suidouble_chat {
         transfer::share_object(chat_top_message);
     }
 
+    public entry fun post_pay_with_coin_vector(
+        chat_shop: &mut ChatShop,
+        coins: vector<Coin<SUI>>,
+        text: vector<u8>,
+        metadata: vector<u8>,
+        ctx: &mut TxContext
+    ) {
+        let base = vector::pop_back(&mut coins);
+        pay::join_vec(&mut base, coins);
+        post_pay(chat_shop, base, text, metadata, ctx);
+    }
 
     /// Mint (post) a ChatResponse object 
     public entry fun reply(