suidouble 0.0.8 → 0.0.9

package/lib/SuiEvent.js

@@ -12,6 +12,13 @@ class SuiEvent extends SuiCommonMethods {
         this._data = params.data || {};
     }
 
+    /**
+     * In module type name, without package and module prefix
+     */
+    get typeName() {
+        return this._data ? this._data.type.split('::').pop() : null;
+    }
+
     get data() {
         return this._data;
     }

package/lib/SuiMemoryObjectStorage.js

@@ -11,6 +11,12 @@ class SuiMemoryObjectStorage extends SuiCommonMethods {
         return Object.values(this._objects);
     }
 
+    findMostRecentByTypeName(typeName) {
+        return this.findMostRecent((object) => {
+                return (object.typeName == typeName);
+            });
+    }
+
     find(filterFunction) {
         for (const id in this._objects) {
             if (filterFunction(this._objects[id])) {

package/lib/SuiPackage.js

@@ -43,6 +43,19 @@ class SuiPackage extends SuiObject {
         return this._modules;
     }
 
+    async getModule(moduleName) {
+        await this.checkOnChainIfNeeded();
+        return this._modules[moduleName];
+    }
+
+    get isBuilt() {
+        return this._isBuilt;
+    }
+
+    get version() {
+        return Number(this._publishedVersion); // return as Number in getter
+    }
+
     async isOnChain() {
         try {
             await this.checkOnChainIfNeeded();
@@ -223,9 +236,6 @@ class SuiPackage extends SuiObject {
             },
         });
 
-        console.log('result', result);
-
-
         if (result?.data?.version) {
             this._publishedVersion = BigInt(result?.data?.version); // not sure, but it's string in response, so let's convert it to bigint, who knows
             this._isPublished = true;

package/lib/SuiPackageModule.js

@@ -104,8 +104,6 @@ class SuiPackageModule extends SuiCommonMethods {
         const listMutated = [];
         const listDeleted = [];
 
-        console.error('result', result);
-
         for (const objectChange of result.objectChanges) {
             if (objectChange.objectId) {
                 if (this.objectStorage.byAddress(objectChange.objectId)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "suidouble",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "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": {
@@ -26,5 +26,11 @@
   },
   "devDependencies": {
     "tap": "^16.3.4"
+  },
+  "tap": {
+    "branches": 90,
+    "lines": 90,
+    "functions": 90,
+    "statements": 90
   }
 }

package/test/sui_master_onlocal.test.js

@@ -2,11 +2,18 @@
 
 const t = require('tap');
 const { test } = t;
+const path = require('path');
 
 const { SuiMaster, SuiLocalTestValidator } = require('..');
 
 let suiLocalTestValidator = null;
 let suiMaster = null;
+let contract = null;
+
+let contractAddressV1 = null;
+let contractAddressV2 = null;
+
+let chatShopObjectId = null;
 
 test('spawn local test node', async t => {
     suiLocalTestValidator = await SuiLocalTestValidator.launch();
@@ -34,6 +41,171 @@ test('request sui from faucet', async t => {
     t.ok(balanceAfter > balanceBefore);
 });
 
+test('attach a local package', async t => {
+    contract = suiMaster.addPackage({
+        path: path.join(__dirname, './test_move_contracts/suidouble_chat/'),
+    });
+    // there's nothing in contract yet, it's not built, not published (don't know it's id on chain)
+    //
+    // we can check that contract's objectStorage is the same instance as on master. Reminder, it's shared between all connections to same chain
+    t.equal(contract.objectStorage, suiMaster.objectStorage);
+
+    // lets try to build it
+    await contract.build();
+
+    t.ok(contract.isBuilt);
+
+    // and publish
+
+    await contract.publish();
+
+    t.ok(contract.address); // there should be some address
+    t.ok(contract.id); // same as id
+    t.ok(`${contract.address}`.indexOf('0x') === 0); // adress is string starting with '0x'
+
+    t.equal(contract.version, 1);
+
+    // there should be module 'suidouble_chat' on the contract we published
+    t.ok(contract.modules.suidouble_chat);
+
+    // we can check that contract's objectStorage is the same instance as on master. Reminder, it's shared between all connections to same chain
+    t.equal(contract.modules.suidouble_chat.objectStorage, suiMaster.objectStorage);
+
+    contractAddressV1 = contract.address;
+
+    // we'd need to .build() again after changes here. But it lets you upgrade package with very same code
+    await contract.upgrade();
+
+    t.not(contract.address, contractAddressV1);
+    t.equal(contract.version, 2);
+
+    contractAddressV2 = contract.address;
+
+    // let's quickly check it worked, there should be event ChatShopCreated created and we can fetch it from contract's module
+    const eventsResponse = await contract.modules.suidouble_chat.fetchEvents();
+    // response is an instance of SuiPaginatedResponse
+    let foundChatShopCreatedEvent = false;
+    for (const event of eventsResponse.data) {
+        if (event.typeName === 'ChatShopCreated') {
+            foundChatShopCreatedEvent = true;
+        }
+    }
+
+    t.ok(foundChatShopCreatedEvent);
+});
+
+test('attach a package by address on the blockchain', async t => {
+    suiMaster = new SuiMaster({provider: suiLocalTestValidator, as: 'somebody'});
+    await suiMaster.initialize();
+
+    contract = await suiMaster.addPackage({
+        id: contractAddressV2,
+    });
+    const eventsResponse = await contract.fetchEvents('suidouble_chat');
+
+    let foundChatShopCreatedEvent = false;
+    for (const event of eventsResponse.data) {
+        if (event.typeName === 'ChatShopCreated') {
+            foundChatShopCreatedEvent = true;
+            chatShopObjectId = event.parsedJson.id;
+        }
+    }
+
+    // there should be ChatShopCreated event
+    t.ok(foundChatShopCreatedEvent);
+
+    // it should have id of ChatShop object
+    t.ok(chatShopObjectId);
+
+    // there should be module 'suidouble_chat' on the contract
+    t.ok(contract.modules.suidouble_chat);
+});
+
+test('can find a package on the blockchain by expected module name (in owned)', async t => {
+    suiMaster = new SuiMaster({provider: suiLocalTestValidator, as: 'somebody'});
+    await suiMaster.initialize();
+
+    contract = await suiMaster.addPackage({
+        modules: ['suidouble_chat'],
+    });
+    const eventsResponse = await contract.fetchEvents('suidouble_chat');
+
+    let foundChatShopCreatedEvent = false;
+    for (const event of eventsResponse.data) {
+        if (event.typeName === 'ChatShopCreated') {
+            foundChatShopCreatedEvent = true;
+            chatShopObjectId = event.parsedJson.id;
+        }
+    }
+
+    // there should be ChatShopCreated event
+    t.ok(foundChatShopCreatedEvent);
+    // it should have id of ChatShop object
+    t.ok(chatShopObjectId);
+
+    // there should be module 'suidouble_chat' on the contract
+    t.ok(contract.modules.suidouble_chat);
+
+    // it should find most recent version of the package
+    t.equal(contract.version, 2);
+});
+
+test('execute contract methods', async t => {
+    const moveCallResult = await contract.moveCall('suidouble_chat', 'post', [chatShopObjectId, 'the message', '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, 'the message');
+
+    // now lets post a reply to the thread
+    // we need a ChatTopMessage to pass to move's 'reply' function
+    // we can find it via ChatTopMessageCreated events or from previous method execution results
+    // find from local objectStorage (where previous results are stored)
+    const chatTopMessage = contract.objectStorage.findMostRecentByTypeName('ChatTopMessage');
+    t.ok(chatTopMessage);
+
+    const responseTextAsBytes = [].slice.call(new TextEncoder().encode('ขอบคุณครับ, 🇺🇦')); // regular array with utf data
+    const moveCallResult2 = await contract.moveCall('suidouble_chat', 'reply', [chatTopMessage.id, responseTextAsBytes, 'metadata']);
+
+    // there're at least some object created
+    t.ok(moveCallResult2.created.length > 0);
+
+    let responseText = null;
+    moveCallResult2.created.forEach((obj)=>{
+        if (obj.typeName == 'ChatResponse') {
+            responseText = obj.fields.text;
+        }
+    });
+    // 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
+    responseText = new TextDecoder().decode(new Uint8Array(responseText));
+
+    t.equal(responseText, 'ขอบคุณครับ, 🇺🇦');
+});
+
 test('stops local test node', async t => {
     SuiLocalTestValidator.stop();
 });

package/test/test_move_contracts/suidouble_chat/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_chat/Move.toml

@@ -0,0 +1,10 @@
+[package]
+name = "suidouble_chat"
+version = "0.0.1"
+
+[dependencies]
+Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "testnet" }
+
+[addresses]
+suidouble_chat =  "0x0"
+sui =  "0000000000000000000000000000000000000000000000000000000000000002"

package/test/test_move_contracts/suidouble_chat/compiled.json

@@ -0,0 +1 @@
+{"modules":["oRzrCwYAAAALAQAQAhAyA0JQBJIBGgWsAYcBB7MCtQMI6AVABqgGKArQBlEMoQfQAg3xCQYAJAEOARIBFAEaASMBKAEpAAUDAAAHAwAAAwMAAAEIAAAECAAABgwAAAIMAAEABAEAAQQIBwAECwQABQkCAAcKAgAAFwABAAAbAgEAAB4DAQABKwEOAQACDBcBAgcMAhUZGgEHAh0bHAIHDAMTDAEBAwQWFAoBCAQZAAQABCoJCgAGIgwBAQgGKAgBAQgHIAUGAAwHBwsDDQsPBxIHEwgPCBUEFgsVBRgGFgwdAQcICwAEBggECgIKAgcICwQHCAUKAgoCBwgLAQgJAQYICwEFAQgDAgkABQEGCAkBCAgBCAABCQABCAoBCwcBCQABCAQICAkICAUICAgGCAkIBQgJAQIBCAEBCAIBBgkAAQgFAgoCCAYDBwgJCQAJAQEKAgIGCAkJAAEBAgcICQkAAQkBAQgGB0JhbGFuY2UMQ2hhdE93bmVyQ2FwDENoYXRSZXNwb25zZRNDaGF0UmVzcG9uc2VDcmVhdGVkCENoYXRTaG9wD0NoYXRTaG9wQ3JlYXRlZA5DaGF0VG9wTWVzc2FnZRVDaGF0VG9wTWVzc2FnZUNyZWF0ZWQCSUQDU1VJCVR4Q29udGV4dANVSUQDYWRkBmF1dGhvcgdiYWxhbmNlDGNoYXRfc2hvcF9pZBNjaGF0X3RvcF9tZXNzYWdlX2lkFGNoYXRfdG9wX3Jlc3BvbnNlX2lkFGR5bmFtaWNfb2JqZWN0X2ZpZWxkBGVtaXQFZXZlbnQHZXhpc3RzXwJpZARpbml0CG1ldGFkYXRhA25ldwZvYmplY3QEcG9zdAVwcmljZQZyZW1vdmUFcmVwbHkPcmVzcG9uc2VzX2NvdW50BnNlbmRlcgVzZXFfbgxzaGFyZV9vYmplY3QDc3VpDnN1aWRvdWJsZV9jaGF0BHRleHQOdG9wX21lc3NhZ2VfaWQPdG9wX3Jlc3BvbnNlX2lkCHRyYW5zZmVyCnR4X2NvbnRleHQMdWlkX3RvX2lubmVyBHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAgAAAAAAAAMIAAAAAAAAAAAKAhEQYXNfY2hhdF9yZXNwb25zZQACARYICAECAhYICCcICAICAxYICCYICCEDAwIBFggJBAIDFggJHAMOCwcBCAoFAgUWCAkPCAgRCAgNBR8DBgIGFggJEAgIDQUlCgIYCgIhAwAAAAAEFAoAEQkSAwoALhENOAALABEJDAEOAREKEgA4AQsBBugDAAAAAAAAOAISBDgDAgEBBAAQRQ4BQREHACUEBgUMCwMBCwABBwEnCgMRCQwLCgMRCQwJDgsRCg4JEQoSATgEDgkRCg4LEQoGAAAAAAAAAAASAjgFCwsMBAsAOAYMBQoDLhENDAYOCREKDAcLBAsFCwcLBgYAAAAAAAAAABIFDAoLCQ4KOAcLAy4RDQsBCwIGAAAAAAAAAAASBgwIDQoPAAcCCwg4CAsKOAkCAgEEAARADgFBEQcAJQQGBQwLAwELAAEHAScKABAABwI4CgQZCgAPAAcCOAsKABABFDgMCgAQAhQGAQAAAAAAAAAWCgAPAhUKAxEJDAQOBBEKCgAQABEKCgAQAhQSAjgFCwQKAC44BwoDLhENCwELAgsAEAIUEgYLAy4RDTgMAgUABQMFBAA="],"dependencies":["0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000002"],"digest":[160,183,189,147,87,240,81,132,236,190,75,225,74,68,254,14,106,61,173,195,201,119,140,108,230,103,29,238,48,162,45,170]}

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

@@ -0,0 +1,221 @@
+
+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 sui::dynamic_object_field::{Self};
+
+    use sui::sui::SUI;
+    use sui::balance::{Self, Balance};
+    
+    use std::debug;
+
+    use sui::event::emit;
+
+    /// Max text length.
+    const MAX_TEXT_LENGTH: u64 = 512;
+
+    /// Text size overflow.
+    const ETextOverflow: u64 = 0;
+
+    // ======== Events =========
+
+    /// Event. When a new chat has been created.
+    struct ChatShopCreated has copy, drop { id: ID }
+    struct ChatTopMessageCreated has copy, drop { id: ID, top_response_id: ID }
+    struct ChatResponseCreated has copy, drop { id: ID, top_message_id: ID, seq_n: u64 }
+
+    /// Capability that grants an owner the right to collect profits.
+    struct ChatOwnerCap has key { id: UID }
+
+    /// A shared object. `key` ability is required.
+    struct ChatShop has key {
+        id: UID,
+        price: u64,
+        balance: Balance<SUI>
+    }
+
+    struct ChatTopMessage has key, store {
+        id: UID,
+        chat_shop_id: ID,
+        chat_top_response_id: ID,
+        author: address,
+        responses_count: u64,
+    }
+
+    struct ChatResponse has key, store {
+        id: UID,
+        chat_top_message_id: ID,
+        author: address,
+        text: vector<u8>,
+        // app-specific metadata. We do not enforce a metadata format and delegate this to app layer.
+        metadata: vector<u8>,
+        seq_n: u64, // n of message in thread
+    }
+
+    /// Init function is often ideal place for initializing
+    /// a shared object as it is called only once.
+    ///
+    /// To share an object `transfer::share_object` is used.
+    fun init(ctx: &mut TxContext) {
+        transfer::transfer(ChatOwnerCap {
+            id: object::new(ctx)
+        }, tx_context::sender(ctx));
+
+        let id = object::new(ctx);
+        emit(ChatShopCreated { id: object::uid_to_inner(&id) });
+
+        // Share the object to make it accessible to everyone!
+        transfer::share_object(ChatShop {
+            id: id,
+            price: 1000,
+            balance: balance::zero()
+        })
+    }
+
+    // /// Simple ChatResponse.text getter.
+    // public fun text(chat_response: &ChatResponse): String {
+    //     chat_response.text
+    // }
+
+    /// Mint (post) a chatMessage 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, 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);
+    }
+
+    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);
+
+        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 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));
+    }
+
+
+
+    #[test]
+    public fun test_module_init() {
+        use sui::test_scenario;
+
+        // Create test address representing game admin
+        let admin = @0xBABE;
+        let somebody = @0xFAFE;
+        let anybody = @0xFAAE;
+        // let player = @0x0;
+
+        // First transaction to emulate module initialization
+        let scenario_val = test_scenario::begin(admin);
+        let scenario = &mut scenario_val;
+
+        // Run the module initializers
+        test_scenario::next_tx(scenario, admin);
+        {
+            init(test_scenario::ctx(scenario));
+
+        };
+        // Run the module initializers
+        test_scenario::next_tx(scenario, somebody);
+        {
+            let chat_shop = test_scenario::take_shared<ChatShop>(scenario);
+            // let chat_shop_ref = &chat_shop;
+            debug::print(&chat_shop);
+
+            let chat_shop_ref = &chat_shop;
+            post(chat_shop_ref, b"test", b"metadata", test_scenario::ctx(scenario));
+
+            // post(chat_shop_ref, b"test", b"metadata", test_scenario::ctx(scenario));
+
+            test_scenario::return_shared(chat_shop);
+        };
+
+        test_scenario::next_tx(scenario, anybody);
+        {    
+            // let chat_top_message = test_scenario::take_from_sender<ChatTopMessage>(scenario);
+            let chat_top_message = test_scenario::take_shared<ChatTopMessage>(scenario);
+            // let chat_shop_ref = &chat_shop;
+            debug::print(&chat_top_message);
+            debug::print(&mut chat_top_message);
+
+            // let chat_top_message_ref = &chat_top_message;
+            reply(&mut chat_top_message, b"response", b"metadata", test_scenario::ctx(scenario));
+
+            // post(chat_shop_ref, b"test", b"metadata", test_scenario::ctx(scenario));
+
+            test_scenario::return_shared(chat_top_message);
+            // test_scenario::return_to_sender(scenario, chat_top_message);
+        };
+
+        test_scenario::next_tx(scenario, anybody);
+        {    
+            // let chat_top_message = test_scenario::take_from_sender<ChatTopMessage>(scenario);
+            let chat_top_message = test_scenario::take_shared<ChatTopMessage>(scenario);
+            // let chat_shop_ref = &chat_shop;
+            debug::print(&mut chat_top_message);
+
+            // let chat_top_message_ref = &chat_top_message;
+            reply(&mut chat_top_message, b"response", b"metadata", test_scenario::ctx(scenario));
+
+            // post(chat_shop_ref, b"test", b"metadata", test_scenario::ctx(scenario));
+
+            test_scenario::return_shared(chat_top_message);
+            // test_scenario::return_to_sender(scenario, chat_top_message);
+        };
+        test_scenario::end(scenario_val);
+    }
+}