suidouble 0.0.11 → 0.0.13

package/README.md

@@ -155,6 +155,14 @@ const res = await contract.moveCall('chat', 'post', ['0x10cded4f9df05e37b44e3be2
     }
 ```
 
+If you need to transfer some SUI as part of executing contract method, you can use a magic parameter in form of '<SUI>400000000000' where 400000000000 is the amount of MIST you want to send. SuiPackageModule will convert this amount to Coin object using Transactions.SplitCoins method.
+
+```javascript
+const moveCallResult = await contract.moveCall('suidouble_chat', 'post_pay', [chatShopObjectId, '<SUI>400000000000', messageText, 'metadata']);
+```
+
+@todo: sending other Coins
+
 ##### fetching objects
 
 There's instance of SuiMemoryObjectStorage attached to every SuiMaster instance. Every smart contract method call adds created and mutated objects to it. You can also attach any object with it's address (id).
@@ -297,6 +305,7 @@ suiInBrowser.addEventListener('connected', async()=>{
 ### Todo
 
 - subscribe to events
+- sending other coins as contract methods execution
 - suiobject invalidation/fetching optimization
 - better documentation
-- unit tests
+- unit tests coverage to 90%+

package/lib/SuiPackageModule.js

@@ -79,7 +79,13 @@ class SuiPackageModule extends SuiCommonMethods {
 
         const callArgs = [];
         for (let param of params) {
-            callArgs.push(tx.pure(param));
+            if (param.indexOf && param.indexOf('<SUI>') === 0) {
+                let amount = BigInt(param.split('>')[1]);
+                const coin = tx.add(sui.Transactions.SplitCoins(tx.gas, [tx.pure(amount)]));
+                callArgs.push(coin);
+            } else {
+                callArgs.push(tx.pure(param));
+            }
         }
         tx.moveCall({
             target: `${this._package.address}::${this._moduleName}::${methodName}`,

package/lib/SuiPaginatedResponse.js

@@ -21,6 +21,24 @@ class SuiPaginatedResponse extends SuiCommonMethods {
         this._data = [];
     }
 
+    /**
+     * Simple itterator to go over all list of items, not caring about pagination/cursors etc. It fetches next page when needed
+     * Optional maxLimit second parameter to stop when reached count
+     * @param {Function taking single argument of item} callbackFunc 
+     * @param {Number} maxLimit 
+     */
+    async forEach(callbackFunc, maxLimit = null) {
+        let curN = 0;
+        do {
+            for (const item of this._data) {
+                if (!maxLimit || curN < maxLimit) {
+                    await callbackFunc(item);
+                } 
+                curN++;
+            }
+        } while( (!maxLimit || curN < maxLimit) && (await this.nextPage()) );
+    }
+
     get hasNextPage() {
         return this._hasNextPage;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "suidouble",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "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_master_onlocal.test.js

@@ -211,6 +211,84 @@ test('execute contract methods', async t => {
     t.equal(responseText, 'ขอบคุณครับ, 🇺🇦');
 });
 
+test('testing paginatedResponse', async t => {
+    const chatTopMessage = contract.objectStorage.findMostRecentByTypeName('ChatTopMessage');
+    t.ok(chatTopMessage);
+
+    // fill method create a lot of responses ( check out contract's code )
+    const moveCallResult = await contract.moveCall('suidouble_chat', 'fill', [chatTopMessage.id, 'the message response', 'metadata']);
+    t.ok(moveCallResult.created.length >= 60); // it's 60 in move code, but let's keep chat flexible
+
+    const eventsResponse = await contract.fetchEvents('suidouble_chat');
+    const idsInEventsDict = {};
+    let responsesInEventsCount = 0;
+    do {
+        for (const event of eventsResponse.data) {
+            if (!idsInEventsDict[event.parsedJson.id]) {
+                idsInEventsDict[event.parsedJson.id] = true;
+                responsesInEventsCount++;
+            }
+        }
+    } while(await eventsResponse.nextPage());
+
+    t.ok(responsesInEventsCount >= 60); // it's 60 in move code, but let's keep chat flexible
+
+    // or using SuiPaginatedResponse forEach itterator:
+    const anotherEventsResponse = await contract.fetchEvents('suidouble_chat');
+    let loopsInForEach = 0;
+    const idsInLoopDict = {};
+    await anotherEventsResponse.forEach(async (event)=>{ // 
+        if (!idsInLoopDict[event.parsedJson.id]) {
+            idsInLoopDict[event.parsedJson.id] = true;
+            loopsInForEach++;
+        }
+    });
+
+    t.ok(loopsInForEach >= 60); // it's 60 in move code, but let's keep chat flexible
+});
+
+test('testing move call with coins', async t => {
+    const balanceWas = await suiMaster.getBalance();
+
+    const longMessageYouCanNotPostForFree = ('message ').padEnd(500, 'test');
+    // can't post it for free (as per contract design)
+    t.rejects(contract.moveCall('suidouble_chat', 'post', [chatShopObjectId, longMessageYouCanNotPostForFree, 'metadata']));
+
+    // but can post with with post_pay function sending some sui to it
+    const moveCallResult = await contract.moveCall('suidouble_chat', 'post_pay', [chatShopObjectId, '<SUI>400000000000', longMessageYouCanNotPostForFree, 'metadata']);
+
+    // there're at least some object created
+    t.ok(moveCallResult.created.length > 0);
+
+    // by suidouble_chat contract design, ChatTopMessage is an object representing a thread,
+    // it always has at least one ChatResponse (with text of the very first message in thread)
+    let foundChatTopMessage = null;
+    let foundChatResponse = null;
+    let foundText = null;
+    moveCallResult.created.forEach((obj)=>{
+        if (obj.typeName == 'ChatTopMessage') {
+            foundChatTopMessage = true;
+        }
+        if (obj.typeName == 'ChatResponse') {
+            foundChatResponse = true;
+            foundText = obj.fields.text;
+        }
+    });
+
+    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);
+
+    const balanceNow = await suiMaster.getBalance();
+
+    t.ok( balanceNow <= (balanceWas - 400000000000n) );
+});
+
 test('stops local test node', async t => {
     SuiLocalTestValidator.stop();
 });

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

@@ -8,6 +8,7 @@ module suidouble_chat::suidouble_chat {
     use sui::dynamic_object_field::{Self};
 
     use sui::sui::SUI;
+    use sui::coin::{Self, Coin};
     use sui::balance::{Self, Balance};
     
     use std::debug;
@@ -15,11 +16,21 @@ module suidouble_chat::suidouble_chat {
     use sui::event::emit;
 
     /// Max text length.
+    const MAX_TEXT_LENGTH_FREE: u64 = 256;
     const MAX_TEXT_LENGTH: u64 = 512;
 
+    /// Min price for a long message
+    const MIN_PRICE: u64 = 100;
+
     /// Text size overflow.
     const ETextOverflow: u64 = 0;
 
+    /// Not enough funds to pay for the good in question
+    const EInsufficientFunds: u64 = 1;
+
+    /// For when supplied Coin is zero.
+    const EZeroAmount: u64 = 2;
+
     // ======== Events =========
 
     /// Event. When a new chat has been created.
@@ -80,14 +91,56 @@ module suidouble_chat::suidouble_chat {
     //     chat_response.text
     // }
 
-    /// Mint (post) a chatMessage object without referencing another object.
+    /// Mint (post) a ChatTopMessage object without referencing another object.
     public entry fun post(
         chat_shop: &ChatShop,
         text: vector<u8>,
         metadata: vector<u8>,
         ctx: &mut TxContext,
+    ) {
+        assert!(length(&text) <= MAX_TEXT_LENGTH_FREE, ETextOverflow);
+        let id = object::new(ctx);
+        let chat_response_id = object::new(ctx);
+
+        emit(ChatTopMessageCreated { id: object::uid_to_inner(&id), top_response_id: object::uid_to_inner(&chat_response_id),  });
+        emit(ChatResponseCreated { id: object::uid_to_inner(&chat_response_id), top_message_id: object::uid_to_inner(&id), seq_n: 0 });
+
+        let chat_top_message = ChatTopMessage {
+            id: id,
+            chat_shop_id: object::id(chat_shop),
+            author: tx_context::sender(ctx),
+            chat_top_response_id: object::uid_to_inner(&chat_response_id),
+            responses_count: 0,
+        };
+
+        let chat_response = ChatResponse {
+            id: chat_response_id,
+            chat_top_message_id: object::id(&chat_top_message),
+            author: tx_context::sender(ctx),
+            text: text,
+            metadata,
+            seq_n: 0,
+        };
+        dynamic_object_field::add(&mut chat_top_message.id, b"as_chat_response", chat_response);
+
+        transfer::share_object(chat_top_message);
+    }
+
+    /// Mint (post) a ChatTopMessage object without referencing another object.
+    public entry fun post_pay(
+        chat_shop: &mut ChatShop,
+        sui: Coin<SUI>,
+        text: vector<u8>,
+        metadata: vector<u8>,
+        ctx: &mut TxContext,
     ) {
         assert!(length(&text) <= MAX_TEXT_LENGTH, ETextOverflow);
+        assert!(coin::value(&sui) > 0, EZeroAmount);
+        assert!(coin::value(&sui) >= MIN_PRICE, EInsufficientFunds);
+
+        let sui_balance = coin::into_balance(sui);
+        balance::join(&mut chat_shop.balance, sui_balance);
+
         let id = object::new(ctx);
         let chat_response_id = object::new(ctx);
 
@@ -115,13 +168,15 @@ module suidouble_chat::suidouble_chat {
         transfer::share_object(chat_top_message);
     }
 
+
+    /// Mint (post) a ChatResponse object 
     public entry fun reply(
         chat_top_message: &mut ChatTopMessage,
         text: vector<u8>,
         metadata: vector<u8>,
         ctx: &mut TxContext,
     ) {
-        assert!(length(&text) <= MAX_TEXT_LENGTH, ETextOverflow);
+        assert!(length(&text) <= MAX_TEXT_LENGTH_FREE, ETextOverflow);
 
         let dynamic_field_exists = dynamic_object_field::exists_(&chat_top_message.id, b"as_chat_response");
         if (dynamic_field_exists) {
@@ -148,6 +203,79 @@ module suidouble_chat::suidouble_chat {
     }
 
 
+    // /// Mint (post) a ChatResponse object 
+    // public entry fun reply_pay(
+    //     chat_top_message: &mut ChatTopMessage,
+    //     sui: Coin<SUI>,
+    //     text: vector<u8>,
+    //     metadata: vector<u8>,
+    //     ctx: &mut TxContext,
+    // ) acquires ChatShop {
+    //     assert!(length(&text) <= MAX_TEXT_LENGTH, ETextOverflow);
+
+    //     let dynamic_field_exists = dynamic_object_field::exists_(&chat_top_message.id, b"as_chat_response");
+    //     if (dynamic_field_exists) {
+    //         let top_level_chat_response = dynamic_object_field::remove<vector<u8>, ChatResponse>(&mut chat_top_message.id, b"as_chat_response");
+    //         transfer::transfer(top_level_chat_response, chat_top_message.author);
+    //     };
+
+    //     chat_top_message.responses_count = chat_top_message.responses_count + 1;
+        
+    //     let chat_shop = borrow_global_mut<ChatShop>(id_to_address(&chat_top_message.chat_shop_id));
+    //     let sui_balance = coin::into_balance(sui);
+    //     balance::join(&mut chat_shop.balance, sui_balance);
+
+    //     let id = object::new(ctx);
+
+    //     emit(ChatResponseCreated { id: object::uid_to_inner(&id), top_message_id: object::uid_to_inner(&chat_top_message.id), seq_n: chat_top_message.responses_count });
+
+    //     let chat_response = ChatResponse {
+    //         id: id,
+    //         chat_top_message_id: object::id(chat_top_message),
+    //         author: tx_context::sender(ctx),
+    //         text: text,
+    //         metadata,
+    //         seq_n: chat_top_message.responses_count,
+    //     };
+
+    //     transfer::transfer(chat_response, tx_context::sender(ctx));
+    // }
+
+    /// Mint a lot of responses (we need this to unit test SuiPaginatedResponse faster)
+    public entry fun fill(
+        chat_top_message: &mut ChatTopMessage,
+        text: vector<u8>,
+        metadata: vector<u8>,
+        ctx: &mut TxContext,
+    ) {
+        assert!(length(&text) <= MAX_TEXT_LENGTH, ETextOverflow);
+
+        let dynamic_field_exists = dynamic_object_field::exists_(&chat_top_message.id, b"as_chat_response");
+        if (dynamic_field_exists) {
+            let top_level_chat_response = dynamic_object_field::remove<vector<u8>, ChatResponse>(&mut chat_top_message.id, b"as_chat_response");
+            transfer::transfer(top_level_chat_response, chat_top_message.author);
+        };
+
+        let i: u64 = 0;
+
+        while (i < 60) {
+            let id = object::new(ctx);
+
+            emit(ChatResponseCreated { id: object::uid_to_inner(&id), top_message_id: object::uid_to_inner(&chat_top_message.id), seq_n: chat_top_message.responses_count });
+
+            let chat_response = ChatResponse {
+                id: id,
+                chat_top_message_id: object::id(chat_top_message),
+                author: tx_context::sender(ctx),
+                text: text,
+                metadata,
+                seq_n: chat_top_message.responses_count,
+            };
+            transfer::transfer(chat_response, tx_context::sender(ctx));
+            i = i + 1;
+        };
+    }
+
 
     #[test]
     public fun test_module_init() {
@@ -201,6 +329,22 @@ module suidouble_chat::suidouble_chat {
             // test_scenario::return_to_sender(scenario, chat_top_message);
         };
 
+        test_scenario::next_tx(scenario, anybody);
+        {    
+            let chat_shop = test_scenario::take_shared<ChatShop>(scenario);
+            debug::print(&chat_shop);
+
+            // let chat_shop_ref = &chat_shop;
+            let ctx = test_scenario::ctx(scenario);
+            post_pay(&mut chat_shop, coin::mint_for_testing<SUI>(100, ctx), b"test", b"metadata", test_scenario::ctx(scenario));
+
+            // post(chat_shop_ref, b"test", b"metadata", test_scenario::ctx(scenario));
+
+            debug::print(&chat_shop);
+
+            test_scenario::return_shared(chat_shop);
+        };
+
         test_scenario::next_tx(scenario, anybody);
         {    
             // let chat_top_message = test_scenario::take_from_sender<ChatTopMessage>(scenario);