suidouble 0.0.31 → 0.0.33

package/index.js

@@ -8,4 +8,5 @@ module.exports = {
     SuiInBrowser,
     SuiTestScenario,
     SuiLocalTestValidator,
+    MIST_PER_SUI: SuiMaster.MIST_PER_SUI,
 };

package/lib/SuiMaster.js

@@ -3,6 +3,10 @@ const SuiCommonMethods = require('./SuiCommonMethods.js');
 const SuiPackage = require('./SuiPackage.js');
 const SuiPseudoRandomAddress = require('./SuiPseudoRandomAddress.js');
 const SuiMemoryObjectStorage = require('./SuiMemoryObjectStorage.js');
+const SuiPaginatedResponse = require('./SuiPaginatedResponse.js');
+const SuiObject = require('./SuiObject.js');
+const SuiTransaction = require('./SuiTransaction.js');
+const SuiEvent = require('./SuiEvent.js');
 
 class SuiMaster extends SuiCommonMethods {
     constructor(params = {}) {
@@ -104,6 +108,25 @@ class SuiMaster extends SuiCommonMethods {
         return BigInt(sui.MIST_PER_SUI);
     }
 
+    /**
+     * Referencing it here to get rid of circullar dependency. So you can always call SuiObject contructor if you have instance of SuiMaster
+     */
+    get SuiObject() {
+        return SuiObject;
+    }
+    /**
+     * Referencing it here to get rid of circullar dependency. So you can always call SuiTransaction contructor if you have instance of SuiMaster
+     */
+    get SuiTransaction() {
+        return SuiTransaction;
+    }
+    /**
+     * Referencing it here to get rid of circullar dependency. So you can always call SuiEvent contructor if you have instance of SuiMaster
+     */
+    get SuiEvent() {
+        return SuiEvent;
+    }
+
     get objectStorage() {
         return this._objectStorage;
     }
@@ -234,8 +257,68 @@ class SuiMaster extends SuiCommonMethods {
         this.log('balance of', coinType, 'is', ret);
         return ret;
     }
-};
 
+    // export type TransactionFilter =
+	// | { FromOrToAddress: { addr: string } }
+	// | { Checkpoint: string }
+	// | { FromAndToAddress: { from: string; to: string } }
+	// | { TransactionKind: string }
+	// | {
+	// 		MoveFunction: {
+	// 			package: ObjectId;
+	// 			module: string | null;
+	// 			function: string | null;
+	// 		};
+	//   }
+	// | { InputObject: ObjectId }
+	// | { ChangedObject: ObjectId }
+	// | { FromAddress: SuiAddress }
+	// | { ToAddress: SuiAddress };
+
+
+	// /* Whether to show transaction input data. Default to be false. */
+	// showInput: optional(boolean()),
+	// /* Whether to show transaction effects. Default to be false. */
+	// showEffects: optional(boolean()),
+	// /* Whether to show transaction events. Default to be false. */
+	// showEvents: optional(boolean()),
+	// /* Whether to show object changes. Default to be false. */
+	// showObjectChanges: optional(boolean()),
+	// /* Whether to show coin balance changes. Default to be false. */
+	// showBalanceChanges: optional(boolean()),
+    async fetchTransactions(params = {}) {
+        const filter = {};
+        if (params.fromOrToAddress) {
+            filter.FromOrToAddress = { addr: params.fromOrToAddress };
+        }
+
+        const queryParams = {
+            descending_order: false,
+            query: filter,
+            options: {
+                showInput: true,
+                showEffects: true,
+                showEvents: true,
+                showObjectChanges: true,
+                showBalanceChanges: true,
+            },
+            limit: params.limit || 50,
+        };
+        const paginatedResponse = new SuiPaginatedResponse({
+            debug: this._debug,
+            suiMaster: this,
+            params: queryParams,
+            method: 'queryTransactionBlocks',
+            order: params.order,
+        });
+
+        await paginatedResponse.fetch();
+
+        return paginatedResponse;
+    }
+
+};
 
+SuiMaster.MIST_PER_SUI = BigInt(sui.MIST_PER_SUI);
 
 module.exports = SuiMaster;

package/lib/SuiObject.js

@@ -238,6 +238,38 @@ class SuiObject extends SuiCommonMethods {
         }
     }
 
+    /**
+     * Replace data with another suiObject data if it's version is newer compared to this one
+     * @param {SuiObject} suiObject 
+     */
+    replaceWithSuiObjectIfNeeded(suiObject) {
+        if (!suiObject || !suiObject.version || !suiObject.id) {
+            return false;
+        }
+
+        if (!this.idEquals(suiObject.id)) {
+            // should be the same id
+            return false;
+        }
+
+        if (!this.version || suiObject.version > this.version) {
+            this._type = suiObject.type;
+            this._owner = suiObject._owner;
+            this._fields = suiObject._fields;
+            this._display = suiObject._display;
+
+            this._version = suiObject.version;
+
+            if (suiObject.isDeleted) {
+                this.markAsDeleted();
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
     /**
      * Try to fill local object properties with values from ( showObjectChanges = true ) rpc response   
      * @param {Object} objectChange 

package/lib/SuiPackageModule.js

@@ -152,99 +152,59 @@ class SuiPackageModule extends SuiCommonMethods {
                 showDisplay: true,
             },
         });
+        const suiTransaction = new this._suiMaster.SuiTransaction({
+                suiMaster: this._suiMaster,
+                debug: this._debug,
+                data: result,
+            });
 
-        let status = null;
-        if (result && result.effects && result.effects.status && result.effects.status.status) {
-            status = result.effects.status.status;
-        }
+        const status = suiTransaction.status;
 
         const listCreated = [];
         const listMutated = [];
         const listDeleted = [];
 
-        for (const objectChange of result.objectChanges) {
-            if (objectChange.objectId) {
-                if (this.objectStorage.byAddress(objectChange.objectId)) {
-                    this.objectStorage.byAddress(objectChange.objectId).tryToFillDataFromObjectChange(objectChange);
-                } else {
-                    const obj = new SuiObject({
-                        suiMaster: this._suiMaster,
-                        debug: this._debug,
-                        objectChange: objectChange,
-                    });
-
-                    if (obj.address) {
-                        this.objectStorage.push(obj);
-                        
-                        this.emit('added', obj);
-                    }
-                }
+        for (const obj of suiTransaction.results.objects) {
+            if (this.objectStorage.byAddress(obj.id)) {
+                this.objectStorage.byAddress(obj.id).replaceWithSuiObjectIfNeeded(obj);
+            } else {
+                this.objectStorage.push(obj);
+                this.emit('added', obj);
             }
         }
 
-        // Mark objects as deleted so we don't fetch them
-        if (result.effects && result.effects.deleted && result.effects.deleted.length) {
-            for (const effect of result.effects.deleted) {
-                // if (effect.reference && effect.reference.objectId) {
-                //     if (this._objects[effect.reference.objectId]) {
-                //         this.log('object is deleted', effect.reference.objectId);
-                //         this._objects[effect.reference.objectId].markAsDeleted();
-                //     }
-                // }
-                if (effect.objectId) {
-                    if (this.objectStorage.byAddress(effect.objectId)) {
-                        this.log('object is deleted', effect.objectId);
-                        this.objectStorage.byAddress(effect.objectId).markAsDeleted();
-                        this.emit('deleted', this.objectStorage.byAddress(effect.objectId));
-
-                        listDeleted.push(this.objectStorage.byAddress(effect.objectId));
-                    }
-                }
+        for (const obj of suiTransaction.results.deleted) {
+            if (this.objectStorage.byAddress(obj.id)) {
+                this.objectStorage.byAddress(obj.id).markAsDeleted();
+                listDeleted.push(this.objectStorage.byAddress(obj.id));
+                this.emit('deleted', this.objectStorage.byAddress(obj.id));
             }
         }
 
         await this.fetchObjects();
 
-        // Emit events based on result.effects
-        if (result.effects) {
-            const events = ['created', 'mutated']; // events names are the same as properties in result.effects
-
-            for (const eventName of events) {
-                if (result.effects[eventName] && result.effects[eventName].length) {
-                    for (const effect of result.effects[eventName]) {
-                        if (effect.reference && effect.reference.objectId) {
-                            if (this.objectStorage.byAddress(effect.reference.objectId)) {
-                                this.emit(eventName, this.objectStorage.byAddress(effect.reference.objectId));
-
-                                if (eventName === 'created') {
-                                    listCreated.push(this.objectStorage.byAddress(effect.reference.objectId));
-                                } else if (eventName === 'mutated') {
-                                    listMutated.push(this.objectStorage.byAddress(effect.reference.objectId));
-                                }
-                            }
-                        }
-                    }
-                }
+        for (const obj of suiTransaction.results.created) {
+            if (this.objectStorage.byAddress(obj.id)) {
+                listCreated.push(this.objectStorage.byAddress(obj.id)); // it's probably the same instance as it's just created. @todo: check
+                this.emit('created', this.objectStorage.byAddress(obj.id));
+            } else {
+                throw new Error('something is wrong!');
             }
         }
 
-        if (result.events && result.events.length) {
-            for (const event of result.events) {
-                const eventType = event.type;
-                const eventTypeName = eventType.split(':').pop(); // last name, without package and module names
-
-                // const eventData = event.parsedJson;
-
-                const suiEvent = new SuiEvent({
-                    suiMaster: this._suiMaster,
-                    debug: this._debug,
-                    data: event,
-                });
-
-                this.emit(eventTypeName, suiEvent);
+        for (const obj of suiTransaction.results.mutated) {
+            if (this.objectStorage.byAddress(obj.id)) {
+                listMutated.push(this.objectStorage.byAddress(obj.id)); // it may be a different entity, updated via .replaceWithSuiObjectIfNeeded above
+                this.emit('mutated', this.objectStorage.byAddress(obj.id));
+            } else {
+                throw new Error('something is wrong!');
             }
         }
 
+        for (const suiEvent of suiTransaction.events) {
+            this.emit(suiEvent.typeName, suiEvent);
+        }
+
         return {
             created: listCreated,
             mutated: listMutated,

package/lib/SuiPaginatedResponse.js

@@ -1,6 +1,7 @@
 const sui = require('@mysten/sui.js');
 const SuiCommonMethods = require('./SuiCommonMethods.js');
 const SuiEvent = require('./SuiEvent.js');
+const SuiTransaction = require('./SuiTransaction.js');
 
 class SuiPaginatedResponse extends SuiCommonMethods {
     constructor(params = {}) {
@@ -83,6 +84,9 @@ class SuiPaginatedResponse extends SuiCommonMethods {
         if (this._method === 'queryEvents') {
             // convert data to SuiEvent instances
             this._data = response.data.map((raw)=>(new SuiEvent({data: raw, suiMaster: this._suiMaster, debug: this._debug})));
+        } else if (this._method === 'queryTransactionBlocks') {
+            // convert data to SuiEvent instances
+            this._data = response.data.map((raw)=>(new SuiTransaction({data: raw, suiMaster: this._suiMaster, debug: this._debug})));
         } else {
             this._data = response.data;
         }

package/lib/SuiTransaction.js

@@ -0,0 +1,152 @@
+const SuiCommonMethods = require('./SuiCommonMethods.js');
+
+class SuiTransaction extends SuiCommonMethods {
+    constructor(params = {}) {
+        super(params);
+
+        this._debug = !!params.debug;
+        this._suiMaster = params.suiMaster;
+        if (!this._suiMaster) {
+            throw new Error('suiMaster is requried for suiPackage');
+        }
+
+        this._data = params.data || {};
+
+        this._results = null;
+        this._events = null;
+    }
+
+    get data() {
+        return this._data;
+    }
+
+    get status() {
+        let status = null;
+        if (this.data && this.data.effects && this.data.effects.status && this.data.effects.status.status) {
+            status = this.data.effects.status.status;
+        }
+        return status;
+    }
+
+    isSuccessful() {
+        if (this.data && this.data.effects && this.data.effects.status && this.data.effects.status.status) {
+            if (this.data.effects.status.status == 'success') {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    get events() {
+        if (this._events) {
+            return this._events;
+        }
+
+        const events = [];
+
+        if (this.data.events && this.data.events.length) {
+            for (const event of this.data.events) {
+                const suiEvent = new this._suiMaster.SuiEvent({
+                    suiMaster: this._suiMaster,
+                    debug: this._debug,
+                    data: event,
+                });
+
+                events.push(suiEvent);
+            }
+        }
+
+        this._events = events;
+        return this._events;
+    }
+
+    get results() {
+        if (this._results) {
+            return this._results;
+        }
+
+        const objects = {};
+
+        const listCreated = [];
+        const listMutated = [];
+        const listDeleted = [];
+
+        if (this.data.objectChanges) {
+            for (const objectChange of this.data.objectChanges) {
+                if (objectChange.objectId) {
+                    if (objects[objectChange.objectId]) {
+    
+                    } else {
+                        const obj = new this._suiMaster.SuiObject({
+                            suiMaster: this._suiMaster,
+                            debug: this._debug,
+                            objectChange: objectChange,
+                        });
+                        if (obj.address) {
+                            objects[obj.address] = obj;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (this.data.effects) {
+            const events = ['created', 'mutated']; // events names are the same as properties in result.effects
+
+            for (const eventName of events) {
+                if ( this.data.effects[eventName] &&  this.data.effects[eventName].length) {
+                    for (const effect of this.data.effects[eventName]) {
+                        if (effect.reference && effect.reference.objectId) {
+                            if (objects[effect.reference.objectId]) {
+                                if (eventName === 'created') {
+                                    listCreated.push(objects[effect.reference.objectId]);
+                                } else if (eventName === 'mutated') {
+                                    listMutated.push(objects[effect.reference.objectId]);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (this.data.effects.deleted) {
+                for (const effect of this.data.effects.deleted) {
+                    if (effect.objectId) {
+                        if (objects[effect.objectId]) {
+
+                        } else {
+                            const obj = new this._suiMaster.SuiObject({
+                                suiMaster: this._suiMaster,
+                                debug: this._debug,
+                                objectChange: effect,
+                            });
+                            objects[effect.objectId] = obj;
+                        }
+                        objects[effect.objectId].markAsDeleted();
+                        listDeleted.push(objects[effect.objectId]);
+                    }
+                }
+            }
+        }
+
+        this._results = {
+            created: listCreated,
+            mutated: listMutated,
+            deleted: listDeleted,
+            objects: Object.values(objects),
+        };
+
+        return this._results;
+    }
+
+    get timestampMs() {
+        if (this.data.timestampMs) {
+            return parseInt(this.data.timestampMs, 10);
+        } else {
+            return null;
+        }
+    }
+};
+
+module.exports = SuiTransaction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "suidouble",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "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_basic.test.js

@@ -3,7 +3,7 @@
 const t = require('tap');
 const { test } = t;
 
-const { SuiMaster } = require('..');
+const { SuiMaster, MIST_PER_SUI } = require('..');
 
 test('initialization', async t => {
 	t.plan(2);
@@ -62,6 +62,10 @@ test('SuiMaster has MIST_PER_SUI property available as BigInt', async t => {
 
     t.equal(typeof suiMaster.MIST_PER_SUI, 'bigint');
     t.ok(suiMaster.MIST_PER_SUI > BigInt(0));
+
+
+    t.equal(suiMaster.MIST_PER_SUI, SuiMaster.MIST_PER_SUI);
+    t.equal(suiMaster.MIST_PER_SUI, MIST_PER_SUI); // available as global library export too
 });
 
 test('connecting to different chains', async t => {
@@ -84,4 +88,22 @@ test('connecting to different chains', async t => {
     await suiMaster4.initialize();
 
     t.equal(suiMaster4.connectedChain, 'sui:localnet');
-});
+});
+
+// test('get transactions', async t => {
+//     const suiMaster = new SuiMaster({provider: 'main', as: 'somebody'});
+//     await suiMaster.initialize();
+
+//     const paginatedResponse = await suiMaster.fetchTransactions({
+//             fromOrToAddress: '0xffc5bc3732f201892df5d2839b86957abcf42dfe66dc79383fe107f6548bc2bf',
+//         });
+
+//     await paginatedResponse.forEach((suiTransaction)=>{
+//         // console.log(suiTransaction.results);
+//         const objects = suiTransaction.results.objects;
+//         for (const o of objects) {
+//             // console.log(o.id, o.typeName, o.version);
+//         }
+//     }, 10);
+
+// });

package/test/sui_master_onlocal.test.js

@@ -15,6 +15,8 @@ let contractAddressV2 = null;
 
 let chatShopObjectId = null;
 
+let chatResponseToDelete = null;
+
 test('spawn local test node', async t => {
     suiLocalTestValidator = await SuiLocalTestValidator.launch({ testFallbackEnabled: true });
     t.ok(suiLocalTestValidator.active);
@@ -230,6 +232,8 @@ test('execute contract methods', async t => {
     moveCallResult2.created.forEach((obj)=>{
         if (obj.typeName == 'ChatResponse') {
             responseText = obj.fields.text;
+
+            chatResponseToDelete = obj.id; // ChatResponse is moved to be owned by author, so we can store id to try burn_response later
         }
     });
     // messageTextAsBytes = [].slice.call(new TextEncoder().encode(messageText)); // regular array with utf data
@@ -275,6 +279,7 @@ test('testing paginatedResponse', async t => {
     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();
 
@@ -317,6 +322,20 @@ test('testing move call with coins', async t => {
     t.ok( balanceNow <= (balanceWas - 400000000000n) );
 });
 
+test('testing move call deleting object', async t => {
+
+    console.error('chatResponseToDelete', chatResponseToDelete);
+
+    const moveCallResult = await contract.moveCall('suidouble_chat', 'burn_response', [chatResponseToDelete]);
+
+    // there're at least some object created
+    t.ok(moveCallResult.deleted.length > 0);
+
+    t.equal(moveCallResult.deleted[0].id, chatResponseToDelete);
+
+    t.ok(moveCallResult.deleted[0].isDeleted);
+});
+
 test('stops local test node', async t => {
     await SuiLocalTestValidator.stop();
 });

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

@@ -201,6 +201,12 @@ module suidouble_chat::suidouble_chat {
 
         transfer::transfer(chat_response, tx_context::sender(ctx));
     }
+    
+    /// Permanently delete `ChatResponse`
+    public entry fun burn_response(chat_response: ChatResponse, _: &mut TxContext) {
+        let ChatResponse { id, chat_top_message_id: _, author: _, text: _, metadata: _, seq_n: _ } = chat_response;
+        object::delete(id)
+    }
 
 
     // /// Mint (post) a ChatResponse object