suidouble 2.5.0 → 2.16.0

package/package.json

@@ -1,12 +1,21 @@
 {
   "name": "suidouble",
-  "version": "2.5.0",
-  "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",
+  "version": "2.16.0",
+  "description": "JavaScript library for Sui Move smart contracts. Publish, upgrade, and test packages; call contract methods; query objects and events — same code works on Node.js and in the browser.",
   "main": "index.js",
+  "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./index.js"
+    }
+  },
   "type": "module",
   "scripts": {
     "test": "tap -j1 -t120 ./test/*.test.js",
-    "coverage": "tap -j1 -t120 ./test/*.test.js"
+    "typecheck": "npx tsc --noEmit --checkJs",
+    "build:types": "npx tsc",
+    "prepublishOnly": "npx tsc"
   },
   "keywords": [
     "sui",
@@ -14,28 +23,35 @@
     "move",
     "smart contract",
     "smart contracts",
-    "sui.js",
+    "blockchain",
     "web3",
-    "dapps",
-    "dapp"
+    "dapp",
+    "grpc",
+    "graphql"
   ],
   "author": "suidouble (https://github.com/suidouble)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/suidouble/suidouble.git"
+  },
   "license": "Apache-2.0",
   "dependencies": {
-    "@mysten/bcs": "^2.0.2",
-    "@mysten/sui": "^2.5.0",
+    "@mysten/bcs": "^2.0.3",
+    "@mysten/sui": "^2.16.0",
     "@polymedia/coinmeta": "^0.0.24",
     "@scure/bip39": "^1.6.0",
-    "@wallet-standard/core": "^1.1.1",
-    "websocket": "^1.0.35"
+    "@wallet-standard/core": "^1.1.1"
   },
   "devDependencies": {
-    "tap": "^21.5.0"
+    "tap": "^21.5.0",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=18"
   },
   "browser": {
     "child_process": false,
     "fs": false,
     "path": false
-  },
-  "tap": {}
+  }
 }

package/test/build_modules.test.js

@@ -0,0 +1,41 @@
+'use strict'
+
+import t from 'tap';
+import { SuiMaster, SuiLocalTestValidator } from '../index.js';
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const { test } = t;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PACKAGE_PATH = path.join(__dirname, './test_move_contracts/suidouble_chat/');
+
+let suiLocalTestValidator = null;
+let suiMaster = null;
+let contract = null;
+
+
+test('getModulesNamesFromBuild — reads module names from compiled artifacts', async t => {
+    suiMaster = new SuiMaster({ client: 'local', as: 'somebody' });
+    contract = suiMaster.addPackage({ path: PACKAGE_PATH });
+    await contract.build();
+
+    const names = await contract.getModulesNamesFromBuild();
+
+    // returns an array
+    t.ok(Array.isArray(names), 'returns an array');
+
+    // at least one module
+    t.ok(names.length > 0, 'at least one module found');
+
+    // expected module is present
+    t.ok(names.includes('suidouble_chat'), 'includes suidouble_chat');
+
+    // every entry is a non-empty string with no .mv suffix
+    for (const name of names) {
+        t.ok(typeof name === 'string' && name.length > 0, `module name "${name}" is a non-empty string`);
+        t.notOk(name.endsWith('.mv'), `module name "${name}" has no .mv suffix`);
+    }
+});

package/test/coins.test.js

@@ -26,6 +26,7 @@ test('init suiMaster and connect it to local test validator', async t => {
     t.ok(`${suiMaster.address}`.indexOf('0x') === 0); // adress is string starting with '0x'
 });
 
+
 test('type is normalized for SUI', async t => {
     // eveything should be the same:
     const suiCoin1 = suiMaster.suiCoins.get('sui');
@@ -207,27 +208,27 @@ test('have some in balance query', async t => {
 });
 
 
-test('getting coin objects for a transaction', async t => {
-    const suiCoin = suiMaster.suiCoins.get('sui');
+// test('getting coin objects for a transaction', async t => {
+//     const suiCoin = suiMaster.suiCoins.get('sui');
 
-    const wasBalance = await suiCoin.getBalance(suiMaster.address);
+//     const wasBalance = await suiCoin.getBalance(suiMaster.address);
 
-    const tx = new Transaction();
-    const coinInput = await suiCoin.coinOfAmountToTxCoin(tx, suiMaster.address, suiMaster.MIST_PER_SUI); // pick 1 SUI
-    tx.transferObjects([coinInput], '0x1d20dcdb2bca4f508ea9613994683eb4e76e9c4ed371169677c1be02aaf0b12a'); // send it anywhere
+//     const tx = new Transaction();
+//     const coinInput = await suiCoin.coinOfAmountToTxCoin(tx, suiMaster.address, suiMaster.MIST_PER_SUI); // pick 1 SUI
+//     tx.transferObjects([coinInput], '0x1d20dcdb2bca4f508ea9613994683eb4e76e9c4ed371169677c1be02aaf0b12a'); // send it anywhere
 
-    const result = await suiMaster.signAndExecuteTransaction({
-        transaction: tx,
-        requestType: 'WaitForLocalExecution',
-        options: {
-        },
-    });
+//     const result = await suiMaster.signAndExecuteTransaction({
+//         transaction: tx,
+//         requestType: 'WaitForLocalExecution',
+//         options: {
+//         },
+//     });
 
-    const nowBalance = await suiCoin.getBalance(suiMaster.address);
+//     const nowBalance = await suiCoin.getBalance(suiMaster.address);
 
-    t.ok(nowBalance < wasBalance);  /// would be better to calculate everthing + fees + storage rebate, but let's just assume it works for now.
-    // @todo : cover better
-});
+//     t.ok(nowBalance < wasBalance);  /// would be better to calculate everthing + fees + storage rebate, but let's just assume it works for now.
+//     // @todo : cover better
+// });
 
 
 test('stops local test node', async t => {

package/test/custom_transaction.test.js

@@ -0,0 +1,167 @@
+'use strict'
+
+import t from 'tap';
+import { SuiMaster, SuiLocalTestValidator, Transaction, txInput } from '../index.js';
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const { test } = t;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+let suiLocalTestValidator = null;
+let suiMaster = null;
+let contract = null;
+let chatShopId = null;
+
+test('spawn local test node', async t => {
+    suiLocalTestValidator = await SuiLocalTestValidator.launch({ testFallbackEnabled: true });
+    t.ok(suiLocalTestValidator.active);
+});
+
+test('setup — init, fund, publish', async t => {
+    suiMaster = new SuiMaster({ client: suiLocalTestValidator, as: 'somebody', debug: false });
+    await suiMaster.initialize();
+
+    await suiMaster.requestSuiFromFaucet();
+
+    contract = suiMaster.addPackage({
+        path: path.join(__dirname, './test_move_contracts/suidouble_chat/'),
+    });
+    await contract.build();
+    await contract.publish();
+    t.ok(contract.address, 'contract published');
+
+    chatShopId = suiMaster.objectStorage.findMostRecentByTypeName('ChatShop')?.id;
+    t.ok(chatShopId, 'ChatShop found after publish');
+});
+
+test('executeTransaction — custom Transaction built with suiMaster.Transaction', async t => {
+    // build the tx using the Transaction class exposed via suiMaster
+    const tx = new suiMaster.Transaction();
+
+    tx.moveCall({
+        target: `${contract.address}::suidouble_chat::post`,
+        arguments: [
+            tx.object(chatShopId),
+            txInput(tx, 'string', 'custom tx message'),
+            txInput(tx, 'string', 'custom tx metadata'),
+        ],
+    });
+
+    // execute via module.executeTransaction so objectStorage + events are synced
+    const result = await contract.modules.suidouble_chat.executeTransaction(tx);
+
+    t.ok(result.created.length > 0, 'transaction created at least one object');
+
+    let foundTopMessage = false;
+    let foundResponse = false;
+    for (const obj of result.created) {
+        if (obj.typeName === 'ChatTopMessage') foundTopMessage = true;
+        if (obj.typeName === 'ChatResponse')   foundResponse = true;
+    }
+    t.ok(foundTopMessage, 'ChatTopMessage created');
+    t.ok(foundResponse, 'ChatResponse created');
+});
+
+test('executeTransaction — custom Transaction built with imported Transaction class', async t => {
+    // same test using the directly imported Transaction from suidouble
+    const tx = new Transaction();
+
+    tx.moveCall({
+        target: `${contract.address}::suidouble_chat::post`,
+        arguments: [
+            tx.object(chatShopId),
+            txInput(tx, 'string', 'imported Transaction message'),
+            txInput(tx, 'string', 'meta'),
+        ],
+    });
+
+    const result = await contract.modules.suidouble_chat.executeTransaction(tx);
+
+    t.ok(result.created.length > 0, 'transaction created objects');
+    t.ok(result.isSuccessful(), 'transaction is marked successful');
+});
+
+test('executeTransaction — objectStorage is updated after custom tx', async t => {
+    const before = suiMaster.objectStorage.asArray().length;
+
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${contract.address}::suidouble_chat::post`,
+        arguments: [
+            tx.object(chatShopId),
+            txInput(tx, 'string', 'storage sync test'),
+            txInput(tx, 'string', 'meta'),
+        ],
+    });
+
+    await contract.modules.suidouble_chat.executeTransaction(tx);
+
+    const after = suiMaster.objectStorage.asArray().length;
+    t.ok(after > before, `objectStorage grew from ${before} to ${after} after custom tx`);
+
+    // created objects should be findable in objectStorage by type
+    const topMessage = suiMaster.objectStorage.findMostRecentByTypeName('ChatTopMessage');
+    t.ok(topMessage, 'ChatTopMessage is findable in objectStorage after custom tx');
+});
+
+test('suiMaster.signAndExecuteTransaction — low-level path, no objectStorage or event sync', async t => {
+    // module.executeTransaction(tx) is the recommended high-level path:
+    //   - signs and executes the transaction
+    //   - pushes created/mutated objects into suiMaster.objectStorage
+    //   - emits 'added' / 'created' / 'deleted' events on the module
+    //
+    // suiMaster.signAndExecuteTransaction(options) is the raw path underneath it:
+    //   - only signs and submits — returns a SuiTransaction
+    //   - does NOT update objectStorage
+    //   - does NOT emit module events
+    //   - use this when you want full control (e.g. multi-step PTBs, custom include flags)
+
+    const storeBefore = suiMaster.objectStorage.asArray().length;
+
+    const addedViaRaw = [];
+    const onAdded = (ev) => addedViaRaw.push(ev.detail);
+    contract.modules.suidouble_chat.addEventListener('added', onAdded);
+
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${contract.address}::suidouble_chat::post`,
+        arguments: [
+            tx.object(chatShopId),
+            txInput(tx, 'string', 'raw signAndExecute message'),
+            txInput(tx, 'string', 'meta'),
+        ],
+    });
+
+    const suiTransaction = await suiMaster.signAndExecuteTransaction({
+        transaction: tx,
+        include: {
+            effects: true,
+            objectTypes: true,
+        },
+    });
+
+    contract.modules.suidouble_chat.removeEventListener('added', onAdded);
+
+    // the transaction itself succeeded and has a digest
+    t.ok(suiTransaction, 'signAndExecuteTransaction returned a SuiTransaction');
+    t.ok(typeof suiTransaction.digest === 'string' && suiTransaction.digest.length > 0,
+        'SuiTransaction has a digest');
+
+    // created objects are accessible on the result
+    t.ok(suiTransaction.created.length > 0, 'SuiTransaction.created is populated');
+
+    // objectStorage was NOT updated — raw path skips that
+    const storeAfter = suiMaster.objectStorage.asArray().length;
+    t.equal(storeAfter, storeBefore, 'objectStorage was NOT updated by signAndExecuteTransaction');
+
+    // module 'added' event was NOT emitted — raw path skips that too
+    t.equal(addedViaRaw.length, 0, 'module "added" event was NOT emitted by signAndExecuteTransaction');
+});
+
+test('stops local test node', async t => {
+    await SuiLocalTestValidator.stop().catch(() => {});
+    t.pass('stopped');
+});

package/test/event_listeners.test.js

@@ -0,0 +1,171 @@
+'use strict'
+
+import t from 'tap';
+import { SuiMaster, SuiLocalTestValidator } from '../index.js';
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const { test } = t;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+let suiLocalTestValidator = null;
+let suiMaster = null;
+let contract = null;
+let chatShopId = null;
+
+test('spawn local test node', async t => {
+    suiLocalTestValidator = await SuiLocalTestValidator.launch({ testFallbackEnabled: true });
+    t.ok(suiLocalTestValidator.active);
+});
+
+test('setup — init, fund, publish', async t => {
+    suiMaster = new SuiMaster({ client: suiLocalTestValidator, as: 'somebody', debug: false });
+    await suiMaster.initialize();
+
+    await suiMaster.requestSuiFromFaucet();
+
+    contract = suiMaster.addPackage({
+        path: path.join(__dirname, './test_move_contracts/suidouble_chat/'),
+    });
+    await contract.build();
+    await contract.publish();
+    t.ok(contract.address, 'contract published');
+
+    chatShopId = suiMaster.objectStorage.findMostRecentByTypeName('ChatShop')?.id;
+    t.ok(chatShopId, 'ChatShop found after publish');
+});
+
+test('module addEventListener — added/created fire for each created object', async t => {
+    const moduleAdded   = [];
+    const moduleCreated = [];
+
+    const onAdded   = (ev) => moduleAdded.push(ev.detail);
+    const onCreated = (ev) => moduleCreated.push(ev.detail);
+
+    contract.modules.suidouble_chat.addEventListener('added',   onAdded);
+    contract.modules.suidouble_chat.addEventListener('created', onCreated);
+
+    const result = await contract.moveCall('suidouble_chat', 'post', [
+        chatShopId,
+        contract.arg('string', 'listener test'),
+        contract.arg('string', 'meta'),
+    ]);
+
+    contract.modules.suidouble_chat.removeEventListener('added',   onAdded);
+    contract.modules.suidouble_chat.removeEventListener('created', onCreated);
+
+    t.ok(result.created.length > 0, 'moveCall created at least one object');
+
+    // 'created' fires exactly once per chain-created object
+    t.equal(moduleCreated.length, result.created.length,
+        `'created' fired ${moduleCreated.length} times — once per created object`);
+
+    // 'added' fires at least once per chain-created object (may include first-seen mutated)
+    t.ok(moduleAdded.length >= result.created.length,
+        `'added' fired ${moduleAdded.length} times (≥ created count)`);
+
+    // every created object must appear in both listeners
+    for (const created of result.created) {
+        t.ok(moduleAdded.some((o) => o?.id === created.id),
+            `'added' fired for ${created.typeName}`);
+        t.ok(moduleCreated.some((o) => o?.id === created.id),
+            `'created' fired for ${created.typeName}`);
+    }
+
+    // every payload is a SuiObject with a 0x-prefixed id
+    for (const obj of moduleAdded) {
+        t.ok(obj && typeof obj.id === 'string' && obj.id.startsWith('0x'),
+            `'added' payload has a valid id`);
+    }
+});
+
+test('package addEventListener — added is forwarded from module', async t => {
+    const packageAdded = [];
+    const moduleAdded  = [];
+
+    const onPackageAdded = (ev) => packageAdded.push(ev.detail);
+    const onModuleAdded  = (ev) => moduleAdded.push(ev.detail);
+
+    contract.addEventListener('added', onPackageAdded);
+    contract.modules.suidouble_chat.addEventListener('added', onModuleAdded);
+
+    await contract.moveCall('suidouble_chat', 'post', [
+        chatShopId,
+        contract.arg('string', 'package listener test'),
+        contract.arg('string', 'meta'),
+    ]);
+
+    contract.removeEventListener('added', onPackageAdded);
+    contract.modules.suidouble_chat.removeEventListener('added', onModuleAdded);
+
+    t.ok(moduleAdded.length > 0, 'module "added" fired');
+    t.equal(packageAdded.length, moduleAdded.length,
+        'package "added" forwarded every module "added"');
+
+    for (const obj of packageAdded) {
+        t.ok(obj && typeof obj.id === 'string' && obj.id.startsWith('0x'),
+            `package 'added' payload has a valid id`);
+    }
+});
+
+test('removeEventListener — listener stops receiving events after removal', async t => {
+    const received = [];
+    const onAdded = (ev) => received.push(ev.detail);
+
+    contract.modules.suidouble_chat.addEventListener('added', onAdded);
+    contract.modules.suidouble_chat.removeEventListener('added', onAdded);
+
+    await contract.moveCall('suidouble_chat', 'post', [
+        chatShopId,
+        contract.arg('string', 'after removal'),
+        contract.arg('string', 'meta'),
+    ]);
+
+    t.equal(received.length, 0, 'no events received after removeEventListener');
+});
+
+test('module addEventListener — deleted fires for burned object', async t => {
+    // create a ChatResponse to burn
+    const postResult = await contract.moveCall('suidouble_chat', 'post', [
+        chatShopId,
+        contract.arg('string', 'to be burned'),
+        contract.arg('string', 'meta'),
+    ]);
+    const chatResponse = postResult.created.find((o) => o.typeName === 'ChatResponse');
+    t.ok(chatResponse, 'ChatResponse found in created objects');
+
+    // get a reply-owned ChatResponse (burn_response requires an owned ChatResponse)
+    const chatTopMessage = postResult.created.find((o) => o.typeName === 'ChatTopMessage');
+    const replyResult = await contract.moveCall('suidouble_chat', 'reply', [
+        chatTopMessage.id,
+        contract.arg('string', 'reply to burn'),
+        contract.arg('string', 'meta'),
+    ]);
+    const replyResponse = replyResult.created.find((o) => o.typeName === 'ChatResponse');
+    t.ok(replyResponse, 'reply ChatResponse found');
+
+    const moduleDeleted = [];
+    const onDeleted = (ev) => moduleDeleted.push(ev.detail);
+    contract.modules.suidouble_chat.addEventListener('deleted', onDeleted);
+
+    const burnResult = await contract.moveCall('suidouble_chat', 'burn_response', [replyResponse.id]);
+
+    contract.modules.suidouble_chat.removeEventListener('deleted', onDeleted);
+
+    t.ok(burnResult.deleted.length > 0, 'burn recorded at least one deleted object');
+    t.equal(moduleDeleted.length, burnResult.deleted.length,
+        `'deleted' fired ${moduleDeleted.length} times — once per deleted object`);
+
+    for (const obj of moduleDeleted) {
+        t.ok(obj && obj.isDeleted, 'deleted payload is marked isDeleted');
+        t.ok(typeof obj.id === 'string' && obj.id.startsWith('0x'),
+            'deleted payload has a valid id');
+    }
+});
+
+test('stops local test node', async t => {
+    await SuiLocalTestValidator.stop().catch(() => {});
+    t.pass('stopped');
+});