suidouble 2.5.0 → 2.16.0

package/test/failed_transaction.test.js

@@ -0,0 +1,184 @@
+'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('moveCall rejects with a readable error message when transaction aborts', async t => {
+    // 500 chars exceeds suidouble_chat's free-post limit → Move abort (FailedTransaction).
+    // Using 10000 chars would exceed the gRPC transaction size limit instead, producing a
+    // transport-level error rather than a Move execution error.
+    const tooLongText = 'x'.repeat(500);
+
+    let thrownError = null;
+    await contract.moveCall('suidouble_chat', 'post', [
+        chatShopId,
+        contract.arg('string', tooLongText),
+        contract.arg('string', 'metadata'),
+    ]).catch(e => { thrownError = e; });
+
+    t.ok(thrownError, 'moveCall rejected on aborted transaction');
+    t.ok(thrownError instanceof Error, 'thrown value is an Error');
+    t.ok(typeof thrownError.message === 'string' && thrownError.message.length > 0, 'error has a non-empty message');
+
+
+    // the message should carry something useful from the RPC — an abort code or description
+    const msg = thrownError.message.toLowerCase();
+    const hasUsefulInfo = msg.includes('abort') || msg.includes('error') || msg.includes('failed') || msg.includes('overflow');
+    t.ok(hasUsefulInfo, `error message is readable: "${thrownError.message}"`);
+
+    // digest — present if the transaction was committed on chain (may be null for pre-consensus failures)
+    t.ok(thrownError.hasOwnProperty('digest'), 'error has a digest property');
+    if (thrownError.digest) {
+        t.ok(typeof thrownError.digest === 'string' && thrownError.digest.length > 0,
+            `error carries the failed tx digest: "${thrownError.digest}"`);
+    } else {
+        t.pass('digest is null — transaction did not reach consensus (expected for some abort types)');
+    }
+
+    // executionError — full SDK error object
+    t.ok(thrownError.executionError !== undefined, 'error has executionError property');
+    t.ok(thrownError.executionError !== null, 'executionError is not null');
+    t.ok(typeof thrownError.executionError.message === 'string',
+        'executionError.message is a string');
+
+    // suidouble_chat abort code for oversized text — should be a MoveAbort
+    if (thrownError.executionError.MoveAbort) {
+        const abort = thrownError.executionError.MoveAbort;
+        t.ok(typeof abort === 'object', 'MoveAbort is an object');
+        console.log('MoveAbort details:', JSON.stringify(abort));
+    }
+
+    // command index — tells which PTB command aborted (if present)
+    if (thrownError.executionError.command != null) {
+        t.ok(typeof thrownError.executionError.command === 'number',
+            `executionError.command is a number: ${thrownError.executionError.command}`);
+    }
+});
+
+test('objectStorage is not updated after a failed moveCall', async t => {
+    const tooLongText = 'x'.repeat(500);
+    const countBefore = suiMaster.objectStorage.asArray().length;
+
+    await contract.moveCall('suidouble_chat', 'post', [
+        chatShopId,
+        contract.arg('string', tooLongText),
+        contract.arg('string', 'metadata'),
+    ]).catch(() => {});
+
+    const countAfter = suiMaster.objectStorage.asArray().length;
+    t.equal(countAfter, countBefore, 'objectStorage unchanged after failed transaction');
+});
+
+test('module "added" event is not emitted after a failed moveCall', async t => {
+    const tooLongText = 'x'.repeat(500);
+    const emitted = [];
+    const onAdded = (ev) => emitted.push(ev.detail);
+    contract.modules.suidouble_chat.addEventListener('added', onAdded);
+
+    await contract.moveCall('suidouble_chat', 'post', [
+        chatShopId,
+        contract.arg('string', tooLongText),
+        contract.arg('string', 'metadata'),
+    ]).catch(() => {});
+
+    contract.modules.suidouble_chat.removeEventListener('added', onAdded);
+    t.equal(emitted.length, 0, '"added" event not emitted after failed transaction');
+});
+
+test('executeTransaction rejects when the built tx aborts', async t => {
+    const tooLongText = 'x'.repeat(500);
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${contract.address}::suidouble_chat::post`,
+        arguments: [
+            tx.object(chatShopId),
+            txInput(tx, 'string', tooLongText),
+            txInput(tx, 'string', 'metadata'),
+        ],
+    });
+
+    await t.rejects(
+        contract.modules.suidouble_chat.executeTransaction(tx),
+        'executeTransaction rejects on aborted transaction'
+    );
+});
+
+test('gRPC transport error — extremely large input rejected before simulation', async t => {
+    // 10Mb causes the gRPC transport to reject the request before it reaches the node.
+    // This is a different failure path from Move abort (SimulationError) and FailedTransaction:
+    //   - no executionError (no Move execution took place)
+    //   - no digest (tx was never submitted)
+    //   - error is typically a gRPC StatusError (RESOURCE_EXHAUSTED or INVALID_ARGUMENT)
+    const giantText = 'x'.repeat(10_000_000);
+
+    let thrownError = null;
+    await contract.moveCall('suidouble_chat', 'post', [
+        chatShopId,
+        contract.arg('string', giantText),
+        contract.arg('string', 'metadata'),
+    ]).catch(e => { thrownError = e; });
+
+    t.ok(thrownError, 'moveCall rejected with a giant input');
+    t.ok(thrownError instanceof Error, 'thrown value is an Error');
+    t.ok(typeof thrownError.message === 'string' && thrownError.message.length > 0,
+        'error has a message');
+
+    // gRPC transport errors don't carry executionError — it never reached Move execution
+    t.equal(thrownError.executionError, undefined,
+        'no executionError — tx was rejected by transport, not by Move VM');
+
+    // similarly no digest
+    t.equal(thrownError.digest, undefined,
+        'no digest — tx was never submitted to the network');
+
+    console.log(`gRPC error type: ${thrownError.constructor.name}, message: ${thrownError.message}`);
+});
+
+test('a succeeding moveCall still works after a failed one', async t => {
+    const result = await contract.moveCall('suidouble_chat', 'post', [
+        chatShopId,
+        contract.arg('string', 'short valid message'),
+        contract.arg('string', 'metadata'),
+    ]);
+
+    t.ok(result.isSuccessful(), 'transaction is successful');
+    t.ok(result.created.length > 0, 'objects created by the successful call');
+});
+
+test('stops local test node', async t => {
+    await SuiLocalTestValidator.stop().catch(() => {});
+    t.pass('stopped');
+});

package/test/name_service.test.js

@@ -0,0 +1,28 @@
+'use strict'
+
+import t from 'tap';
+import { SuiMaster } from '../index.js';
+
+const { test } = t;
+
+const KNOWN_ADDRESS = '0x1eb7c57e3f2bd0fc6cb9dcffd143ea957e4d98f805c358733f76dee0667fe0b1';
+const KNOWN_NAME = 'adeniyi.sui';
+
+test('defaultNameServiceName — returns null when no address connected', async t => {
+    const suiMaster = new SuiMaster({ client: 'mainnet' });
+    await suiMaster.initialize();
+
+    const name = await suiMaster.defaultNameServiceName();
+    t.equal(name, null, 'returns null in read-only mode (no address connected)');
+});
+
+test('defaultNameServiceName — resolves the primary name for a known address', async t => {
+    const suiMaster = new SuiMaster({ client: 'mainnet' });
+    await suiMaster.initialize();
+
+    suiMaster._address = KNOWN_ADDRESS;
+
+    const name = await suiMaster.defaultNameServiceName();
+
+    t.equal(name, `${KNOWN_NAME}`, `resolved name is exactly "${KNOWN_NAME}"`);
+});

package/test/owned_objects.test.js

@@ -0,0 +1,148 @@
+'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;
+
+test('spawn local test node', async t => {
+    suiLocalTestValidator = await SuiLocalTestValidator.launch({ testFallbackEnabled: true });
+    t.ok(suiLocalTestValidator.active);
+});
+
+test('setup — init, fund, publish, post, fill (creates 60 owned ChatResponse objects)', 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');
+
+    const chatShopId = suiMaster.objectStorage.findMostRecentByTypeName('ChatShop')?.id;
+    t.ok(chatShopId, 'ChatShop found after publish');
+
+    // post creates a ChatTopMessage (shared) and a ChatResponse (owned)
+    await contract.moveCall('suidouble_chat', 'post', [
+        chatShopId,
+        contract.arg('string', 'hello'),
+        contract.arg('string', 'meta'),
+    ]);
+
+    const chatTopMessage = suiMaster.objectStorage.findMostRecentByTypeName('ChatTopMessage');
+    t.ok(chatTopMessage, 'ChatTopMessage found after post');
+
+    // fill creates 60 ChatResponse objects owned by the caller — exceeds the default page limit of 50
+    const fillResult = await contract.moveCall('suidouble_chat', 'fill', [
+        chatTopMessage.id,
+        contract.arg('string', 'fill response'),
+        contract.arg('string', 'meta'),
+    ]);
+    t.ok(fillResult.created.length >= 60, `fill created ${fillResult.created.length} objects (≥ 60)`);
+});
+
+test('wait for GraphQL indexer to catch up', async t => {
+    await new Promise((res) => setTimeout(res, 1000));
+    t.pass('waited');
+});
+
+test('getOwnedObjects — no type filter: forEach counts all objects across pages (> 50)', async t => {
+    const result = await suiMaster.getOwnedObjects({
+        owner: suiMaster.address,
+        limit: 50,
+    });
+
+    t.ok(Array.isArray(result.data), 'data is an array');
+
+    let total = 0;
+    await result.forEach((obj) => {
+        t.ok(obj.id, 'obj has an id');
+        total++;
+    });
+
+    t.ok(total > 50, `total owned objects ${total} > 50 (pagination exercised)`);
+});
+
+test('getOwnedObjects — package scope: forEach counts all package objects across pages (> 50)', async t => {
+    const result = await contract.getOwnedObjects({ limit: 50 });
+
+    t.ok(Array.isArray(result.data), 'data is an array');
+
+    const originalPackageId = await contract.getOriginalPackageId();
+    let total = 0;
+    await result.forEach((obj) => {
+        t.ok(
+            obj.type && obj.type.startsWith(originalPackageId + '::'),
+            `"${obj.typeName}" belongs to the package`
+        );
+        total++;
+    });
+
+    t.ok(total > 50, `total package-scoped objects ${total} > 50 (pagination exercised)`);
+});
+
+test('getOwnedObjects — module scope: forEach counts module objects across pages (> 50)', async t => {
+    const result = await contract.modules.suidouble_chat.getOwnedObjects({ limit: 50 });
+
+    t.ok(Array.isArray(result.data), 'data is an array');
+
+    const originalPackageId = await contract.getOriginalPackageId();
+    const modulePrefix = `${originalPackageId}::suidouble_chat::`;
+    let total = 0;
+    await result.forEach((obj) => {
+        t.ok(
+            obj.type && obj.type.startsWith(modulePrefix),
+            `"${obj.typeName}" belongs to suidouble_chat module`
+        );
+        total++;
+    });
+
+    t.ok(total > 50, `total module-scoped objects ${total} > 50 (pagination exercised)`);
+});
+
+test('getOwnedObjects — struct type (ChatResponse): forEach returns only ChatResponse > 50', async t => {
+    const originalPackageId = await contract.getOriginalPackageId();
+
+    const result = await contract.modules.suidouble_chat.getOwnedObjects({
+        typeName: 'ChatResponse',
+        limit: 50,
+    });
+
+    t.ok(Array.isArray(result.data), 'data is an array');
+
+    let total = 0;
+    await result.forEach((obj) => {
+        t.equal(obj.typeName, 'ChatResponse', 'typeName is ChatResponse');
+        t.ok(
+            obj.type && obj.type.startsWith(`${originalPackageId}::suidouble_chat::ChatResponse`),
+            'full type is correct'
+        );
+        total++;
+    });
+
+    t.ok(total > 50, `total ChatResponse objects ${total} > 50 (pagination exercised)`);
+
+    // struct-typed ≤ module-scoped
+    const moduleResult = await contract.modules.suidouble_chat.getOwnedObjects({ limit: 50 });
+    let moduleTotal = 0;
+    await moduleResult.forEach(() => { moduleTotal++; });
+    t.ok(total <= moduleTotal, 'ChatResponse count ≤ module-scope count');
+});
+
+test('stops local test node', async t => {
+    await SuiLocalTestValidator.stop().catch(() => {});
+    t.pass('stopped');
+});

package/test/rpc.test.js

@@ -14,12 +14,9 @@ const __dirname = path.dirname(__filename);
 let suiMaster = null;
 
 test('spawn local test node', async t => {
-        const rpcClient = SuiMaster.SuiUtils.suiClientForRPC({
-                chain: 'mainnet',
-                url: 'https://fullnode.mainnet.sui.io',
-                rpc: {
-                    // headers: {"x-allthatnode-api-key": "xxxxxxxxxx"},
-                }
+        const rpcClient = SuiMaster.SuiUtils.suiClientForRPC('mainnet', {
+                baseUrl: 'https://fullnode.mainnet.sui.io:443',
+                // fetchInit: { headers: { "x-allthatnode-api-key": "xxxxxxxxxx" } },
             });
             
         const suiMaster = new SuiMaster({

package/test/sui_in_browser.test.js

@@ -60,12 +60,12 @@ test('initialization', async t => {
     t.ok(suiMaster.connectedChain);     // but there's chain
 
     // by default, SuiInBrowser gets you devnet connection (it's overloaded by Wallet Extension current chain)
-    t.equal(suiMaster.connectedChain, 'sui:devnet'); 
+    t.equal(suiMaster.connectedChain, 'devnet'); 
 
 });
 
 test('initialization via mainnet', async t => {
     const suiInBrowser = new SuiInBrowser({defaultChain: 'sui:mainnet'});
     const suiMaster = await suiInBrowser.getSuiMaster();
-    t.equal(suiMaster.connectedChain, 'sui:mainnet'); 
+    t.equal(suiMaster.connectedChain, 'mainnet'); 
 });

package/test/sui_master_basic.test.js

@@ -11,7 +11,6 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 
-
 test('initialization', async t => {
 	t.plan(2);
 
@@ -121,20 +120,20 @@ test('connecting to different chains', async t => {
     const suiMaster = new SuiMaster({client: 'test', as: 'somebody'});
     await suiMaster.initialize();
 
-    t.equal(suiMaster.connectedChain, 'sui:testnet');
+    t.equal(suiMaster.connectedChain, 'testnet');
 
     const suiMaster2 = new SuiMaster({client: 'dev', as: 'somebody'});
     await suiMaster2.initialize();
 
-    t.equal(suiMaster2.connectedChain, 'sui:devnet');
+    t.equal(suiMaster2.connectedChain, 'devnet');
 
     const suiMaster3 = new SuiMaster({client: 'main', as: 'somebody'});
     await suiMaster3.initialize();
 
-    t.equal(suiMaster3.connectedChain, 'sui:mainnet');
+    t.equal(suiMaster3.connectedChain, 'mainnet');
 
     const suiMaster4 = new SuiMaster({client: 'local', as: 'somebody'});
     await suiMaster4.initialize();
 
-    t.equal(suiMaster4.connectedChain, 'sui:localnet');
+    t.equal(suiMaster4.connectedChain, 'localnet');
 });

package/test/sui_master_onlocal.test.js

@@ -199,24 +199,21 @@ test('execute contract methods', async t => {
     // 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;
+    let foundChatResponseObj = null;
     moveCallResult.created.forEach((obj)=>{
         if (obj.typeName == 'ChatTopMessage') {
             foundChatTopMessage = true;
         }
         if (obj.typeName == 'ChatResponse') {
-            foundChatResponse = true;
-            foundText = obj.fields.text;
+            foundChatResponseObj = obj;
         }
     });
 
     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.ok(foundChatResponseObj);
+
+    await foundChatResponseObj.fetchFields();
+    const foundText = suiMaster.utils.bytesFieldToString(foundChatResponseObj.fields.text);
 
     t.equal(foundText, 'the message');
 
@@ -238,17 +235,16 @@ test('execute contract methods', async t => {
     // there're at least some object created
     t.ok(moveCallResult2.created.length > 0);
 
-    let responseText = null;
+    let responseObj = null;
     moveCallResult2.created.forEach((obj)=>{
         if (obj.typeName == 'ChatResponse') {
-            responseText = obj.fields.text;
-
+            responseObj = obj;
             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
-    // 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));
+
+    await responseObj.fetchFields();
+    const responseText = suiMaster.utils.bytesFieldToString(responseObj.fields.text);
 
     t.equal(responseText, 'ขอบคุณครับ, 🇺🇦');
 });
@@ -261,6 +257,9 @@ test('testing paginatedResponse', async t => {
     const moveCallResult = await contract.moveCall('suidouble_chat', 'fill', [chatTopMessage.id, contract.arg('string', 'the message response'), contract.arg('string', 'metadata')]);
     t.ok(moveCallResult.created.length >= 60); // it's 60 in move code, but let's keep chat flexible
 
+    // GraphQL indexer processes events asynchronously — wait for it to catch up
+    await new Promise((res) => setTimeout(res, 1000));
+
     const eventsResponse = await contract.modules.suidouble_chat.fetchEvents({eventTypeName: 'ChatResponseCreated'});
     const idsInEventsDict = {};
     let responsesInEventsCount = 0;
@@ -292,7 +291,6 @@ test('testing paginatedResponse', async t => {
 
 test('find owned module objects with query', async t => {
     const module = await contract.getModule('suidouble_chat');
-    await module.getNormalizedMoveFunction('fill');
 
     const paginatedResponse = await module.getOwnedObjects();
 
@@ -342,22 +340,21 @@ test('testing move call with coins', async t => {
     // 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;
+    let foundChatResponseObj2 = null;
     moveCallResult.created.forEach((obj)=>{
         if (obj.typeName == 'ChatTopMessage') {
             foundChatTopMessage = true;
         }
         if (obj.typeName == 'ChatResponse') {
-            foundChatResponse = true;
-            foundText = obj.fields.text;
+            foundChatResponseObj2 = obj;
         }
     });
 
     t.ok(foundChatTopMessage);
-    t.ok(foundChatResponse);
+    t.ok(foundChatResponseObj2);
 
-    foundText = new TextDecoder().decode(new Uint8Array(foundText));
+    await foundChatResponseObj2.fetchFields();
+    const foundText = suiMaster.utils.bytesFieldToString(foundChatResponseObj2.fields.text);
 
     t.equal(foundText, longMessageYouCanNotPostForFree);
 
@@ -379,6 +376,71 @@ test('testing move call with vector<Coin<..>>', async t => {
     t.ok( balanceNow <= (balanceWas - 400000000000n) ); // vector<Coin<SUI>> paid
 });
 
+test('getUpgradeCapId — returns a 0x-prefixed id string', async t => {
+    const upgradeCapId = await contract.getUpgradeCapId();
+
+    t.ok(upgradeCapId, 'upgradeCapId is truthy');
+    t.equal(typeof upgradeCapId, 'string', 'upgradeCapId is a string');
+    t.ok(upgradeCapId.startsWith('0x'), 'upgradeCapId starts with 0x');
+
+    // calling again should return the same cached value
+    const upgradeCapId2 = await contract.getUpgradeCapId();
+    t.equal(upgradeCapId, upgradeCapId2, 'second call returns the same id (cached)');
+});
+
+test('contract.fetchEvents — package-scope returns events from all modules', async t => {
+    const packageEvents = await contract.fetchEvents();
+
+    t.ok(Array.isArray(packageEvents.data), 'data is an array');
+    t.ok(packageEvents.data.length > 0, 'at least one event found at package scope');
+
+    // should include at least ChatShopCreated emitted at publish time
+    let foundChatShopCreated = false;
+    for (const event of packageEvents.data) {
+        t.ok(event.isSuiEvent, 'each event has isSuiEvent brand');
+        t.ok(typeof event.type === 'string' && event.type.length > 0, 'each event has a type');
+        t.ok(event.type.split('::').length >= 3, 'event type is fully qualified');
+        if (event.typeName === 'ChatShopCreated') {
+            foundChatShopCreated = true;
+        }
+    }
+    t.ok(foundChatShopCreated, 'ChatShopCreated event present at package scope');
+
+    // module-scoped fetchEvents should return a subset of package-scoped events
+    const moduleEvents = await contract.modules.suidouble_chat.fetchEvents();
+    t.ok(moduleEvents.data.length <= packageEvents.data.length, 'module events ≤ package events');
+});
+
+test('SuiObject.fetchTransactions — transaction history via GraphQL', async t => {
+    // use the most recently created ChatTopMessage, which has been touched by at least
+    // the post() call and possibly the fill() call in the paginatedResponse test
+    const chatTopMessage = contract.objectStorage.findMostRecentByTypeName('ChatTopMessage');
+    t.ok(chatTopMessage, 'found a ChatTopMessage in objectStorage');
+
+    // GraphQL indexer processes transactions asynchronously — wait for it to catch up
+    await new Promise((res) => setTimeout(res, 1000));
+
+    const txResponse = await chatTopMessage.fetchTransactions({ limit: 20 });
+
+    t.ok(Array.isArray(txResponse.data), 'data is an array');
+    t.ok(txResponse.data.length > 0, 'at least one transaction touched the ChatTopMessage');
+
+    for (const tx of txResponse.data) {
+        t.ok(typeof tx.digest === 'string' && tx.digest.length > 0, 'each tx has a digest');
+        t.ok(typeof tx.timestampMs === 'number' && tx.timestampMs > 0, 'each tx has a positive timestampMs');
+    }
+
+    // ascending order should give the oldest transaction first
+    const asc = await chatTopMessage.fetchTransactions({ limit: 20, order: 'asc' });
+    const desc = await chatTopMessage.fetchTransactions({ limit: 20, order: 'desc' });
+
+    t.ok(asc.data.length > 0, 'ascending query returns results');
+    t.ok(desc.data.length > 0, 'descending query returns results');
+
+    // first tx in ascending should be older than (or equal to) first tx in descending
+    t.ok(asc.data[0].timestampMs <= desc.data[0].timestampMs, 'ascending oldest ≤ descending newest');
+});
+
 test('testing move call deleting object', async t => {
 
     console.error('chatResponseToDelete', chatResponseToDelete);