suidouble 0.0.6 → 0.0.9

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/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/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/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,16 +1,36 @@
 {
   "name": "suidouble",
-  "version": "0.0.6",
+  "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": {
-    "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"
+  },
+  "tap": {
+    "branches": 90,
+    "lines": 90,
+    "functions": 90,
+    "statements": 90
   }
-}
+}

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,211 @@
+'use strict'
+
+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();
+    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('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);
+    }
+}