@fizzyflow/endless-vector 0.0.7 → 0.0.10

package/test/base.test.js

@@ -1,499 +1,460 @@
-'use strict'
-
-import t, { end } from 'tap';
-import { SuiMaster, SuiLocalTestValidator, SuiObject } from 'suidouble';
-import { fileURLToPath } from 'url';
-import path from 'path';
-import { equalUint8Arrays, formatBytes, randomBytesOfLength } from './helpers.js';
-
+/**
+ * Integration test for EndlessVector SDK methods (create, push, at, concat)
+ * using the seal_walrus_localnet infrastructure and suidouble v2 / gRPC client.
+ *
+ * Run: pnpm test:base  (or pnpm test to run all suites)
+ */
+
+import { beforeAll, afterAll, describe, it, expect } from 'vitest';
 import { EndlessVector } from '../index.js';
-// import { get } from 'http';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+import { equalUint8Arrays, randomBytesOfLength } from './helpers.js';
+import { setupEndlessVectorLocalnet, teardownEndlessVectorLocalnet } from './fixture.js';
 
-const { test } = t;
+const TX_TIMEOUT = 60_000;
 
-let suiLocalTestValidator = null;
+let suiMaster;
+let walrusServer;
+let walrusClient;
+let packageId;
 
-/** @type {?SuiMaster} */
-let suiMaster = null;
-let signAndExecuteTransaction = null;
+// ─── setup ────────────────────────────────────────────────────────────────────
 
-let contract = null;
-
-/** @type {?SuiObject} */
-let endlessVectorRaw = null;     // SuiObject instance
-/** @type {?EndlessVector} */
-let endlessVector = null;        // EndlessVector instance
+beforeAll(async () => {
+    ({ suiMaster, walrusServer, walrusClient, packageId } = await setupEndlessVectorLocalnet());
+    console.log('package id:', packageId);
+});
 
-test('spawn local test node', async t => {
-    suiLocalTestValidator = await SuiLocalTestValidator.launch({ testFallbackEnabled: true, debug: true, });
-    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);
+afterAll(async () => {
+    await teardownEndlessVectorLocalnet();
 });
 
-test('init suiMaster and connect it to local test validator', async t => {
-    suiMaster = new SuiMaster({client: 'local', as: 'noname_tester', debug: true});
-    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'
+// ─── helpers ──────────────────────────────────────────────────────────────────
 
-    signAndExecuteTransaction = async (tx) => {
-        // function accepting Transaction and returning signed and submitted transaction digest
-        const results = await suiMaster.signAndExecuteTransaction({
+function makeSignAndExecute() {
+    return async (tx) => {
+        const result = await suiMaster.signAndExecuteTransaction({
             transaction: tx,
+            // requestType: 'WaitForLocalExecution',
         });
-        return results.digest;
-    }
-});
-
-test('request sui from faucet', async t => {
-    const balanceBefore = await suiMaster.getBalance();
-    await suiMaster.requestSuiFromFaucet();
-    await suiMaster.requestSuiFromFaucet();
-    await suiMaster.requestSuiFromFaucet();
-    await suiMaster.requestSuiFromFaucet();
-    await suiMaster.requestSuiFromFaucet();
-    await suiMaster.requestSuiFromFaucet();
-    const balanceAfter = await suiMaster.getBalance();
-    t.ok(balanceAfter > balanceBefore);
-});
+        return result.digest;
+    };
+}
 
-test('attach a local package', async t => {
-    contract = suiMaster.addPackage({
-        path: path.join(__dirname, '../../move'),
+async function createEV(array = null) {
+    return EndlessVector.create({
+        suiClient: suiMaster.client,
+        packageId,
+        walrusClient,
+        aggregatorUrl: walrusServer?.url,
+        senderAddress: suiMaster.address,
+        signAndExecuteTransaction: makeSignAndExecute(),
+        ...(array ? { array } : {}),
     });
-    await contract.build({ withUnpublishedDependencies: true, });
-    await contract.publish();
-});
-
+}
 
-test('test raw create transaction', async t => {
-    const arr = randomBytesOfLength(120 * 1024); // 100KB
-    
-    const tx = new suiMaster.Transaction();
-    const vectorTxInput = await EndlessVector.getCreateTransactionAndReturnVectorInput({
-        packageId: contract.id,
-    }, arr, tx);
-    tx.transferObjects([vectorTxInput], tx.pure.address(suiMaster.address));
-    
-    t.ok(tx);
-    let digest = null;
-    try {
-        digest = await signAndExecuteTransaction(tx);
-        t.ok(digest);
-    } catch (e) {
-        console.error('Error preparing transaction:', e);
-    }
-
-    const transactionBlockResponse = await suiMaster.client.waitForTransaction({
-        digest: digest,
-        options: { showObjectChanges: true, },
-    }); 
-
-    // Find the created EndlessVector object
-    const objectChanges = transactionBlockResponse.objectChanges || [];
-    const createdVector = objectChanges.find(
-        change => change.type === 'created' &&
-                    change.objectType &&
-                    change.objectType.includes('endless_vector::EndlessVector')
-    );
-
-    const createdVectorId = createdVector ? createdVector.objectId : null;
-    t.ok(createdVectorId, 'Created EndlessVector object should have an ID');
-
-    const loadBack = new EndlessVector({
+function makeEV(id) {
+    return new EndlessVector({
         suiClient: suiMaster.client,
-        id: createdVectorId,
+        id,
+        packageId,
+        signAndExecuteTransaction: makeSignAndExecute(),
     });
-    await loadBack.initialize();
-
-    t.ok(loadBack.length === 1, `Loaded vector should have length 1, got ${loadBack.length}`);
-    const getBack = await loadBack.at(0);
-    t.ok(equalUint8Arrays(getBack, arr), 'Data retrieved from loaded vector should match original data');
-});
+}
 
+// ─── tests ────────────────────────────────────────────────────────────────────
 
-test('make a test EndlessVector with few chunks in a single tx', async t => {
-    const data = [
-        randomBytesOfLength(1 * 1024),
-        randomBytesOfLength(2 * 1024),
-        randomBytesOfLength(3 * 1024),
-    ];
-
-    const testEndlessVector = await EndlessVector.create({
-        array: data,
-        suiClient: suiMaster.client, // instance of Sui SDK SuiClient
-        packageId: contract.id, // provide packageId and signAndExecuteTransaction to make EndlessVector writable
-        signAndExecuteTransaction: signAndExecuteTransaction,
+describe('deployment', () => {
+    it('publishes the combined package', () => {
+        expect(packageId).toMatch(/^0x[0-9a-f]+$/);
     });
-
-    const getBack0 = await testEndlessVector.at(0);
-    const getBack1 = await testEndlessVector.at(1);
-    const getBack2 = await testEndlessVector.at(2);
-
-    t.ok(equalUint8Arrays(getBack0, data[0]));
-    t.ok(equalUint8Arrays(getBack1, data[1]));
-    t.ok(equalUint8Arrays(getBack2, data[2]));
-
-    t.ok(testEndlessVector.length === 3);
-    t.ok(testEndlessVector.binaryLength === 6 * 1024);
 });
 
-test('make a test EndlessVector and push single Uint8Array to it', async t => {
-    endlessVector = await EndlessVector.create({
-        suiClient: suiMaster.client, // instance of Sui SDK SuiClient
-        packageId: contract.id, // provide packageId and signAndExecuteTransaction to make EndlessVector writable
-        signAndExecuteTransaction: signAndExecuteTransaction,
-    });
-
-    t.ok(endlessVector);
-    t.ok(endlessVector.id);
-    t.ok(endlessVector.isWritable); // we provided packageId and signAndExecuteTransaction
+describe('raw create transaction', () => {
+    it('creates EndlessVector with 120KB payload via raw tx and reads it back', async () => {
+        const arr = randomBytesOfLength(120 * 1024);
 
-    await endlessVector.push(new Uint8Array([1,2,3]));
-
-    const getBack = await endlessVector.at(0);
-    t.ok(equalUint8Arrays(getBack, new Uint8Array([1,2,3])));
+        const tx = new suiMaster.Transaction();
+        const vectorTxInput = await EndlessVector.getCreateTransactionAndReturnVectorInput(
+            { packageId },
+            arr,
+            tx,
+        );
+        tx.transferObjects([vectorTxInput], tx.pure.address(suiMaster.address));
 
-    await endlessVector.initialize(); // endlessVector.at(0) calles initialize() internally, but we call it again to keep code clear
+        const signAndExecute = makeSignAndExecute();
+        const digest = await signAndExecute(tx);
 
-    t.ok(endlessVector.length === 1);
-    t.ok(endlessVector.binaryLength === 3);
-});
+        const txResult = await suiMaster.client.waitForTransaction({
+            digest,
+            include: { effects: true, objectTypes: true },
+        });
+        const txData = txResult.Transaction ?? txResult.FailedTransaction;
+        expect(txData?.status?.success).toBe(true);
 
-test('push Uint8Array larger than max_pure_argument_size to it', async t => {
-    const largeArray = randomBytesOfLength(30 * 1024); // 30KB
-    await endlessVector.push(largeArray);
+        const objectTypes = txData.objectTypes ?? {};
+        const created = txData.effects?.changedObjects?.find(
+            c => c.idOperation === 'Created' &&
+                 (objectTypes[c.objectId] ?? '').includes('EndlessWalrusVector'),
+        );
+        expect(created).toBeDefined();
 
-    const getBack = await endlessVector.at(1);
-    t.ok(equalUint8Arrays(getBack, largeArray));
-    t.ok(getBack.length === 30*1024);
+        const loadBack = makeEV(created.objectId);
+        await loadBack.initialize();
 
-    t.ok(endlessVector.length === 2);
-    t.ok(endlessVector.binaryLength === 3 + 30*1024);
+        expect(loadBack.length).toBe(1);
+        const back = await loadBack.at(0);
+        expect(equalUint8Arrays(back, arr)).toBe(true);
+    }, TX_TIMEOUT);
 });
 
-test('push Uint8Array larger than max_pure_argument_size to it', async t => {
-    const largeArray = randomBytesOfLength(120 * 1024); // 120KB
-    await endlessVector.push(largeArray);
-
-    const getBack = await endlessVector.at(2);
-    t.ok(equalUint8Arrays(getBack, largeArray));
-    t.ok(getBack.length === 120*1024);
+describe('create with array of chunks', () => {
+    it('creates EndlessVector with 3 pre-loaded chunks and reads each back', async () => {
+        const data = [
+            randomBytesOfLength(1 * 1024),
+            randomBytesOfLength(2 * 1024),
+            randomBytesOfLength(3 * 1024),
+        ];
 
-    t.ok(endlessVector.length === 3);
-    t.ok(endlessVector.binaryLength === 3 + 30*1024 + 120*1024);
-});
+        const ev = await createEV(data);
 
+        expect(equalUint8Arrays(await ev.at(0), data[0])).toBe(true);
+        expect(equalUint8Arrays(await ev.at(1), data[1])).toBe(true);
+        expect(equalUint8Arrays(await ev.at(2), data[2])).toBe(true);
 
-test('throws an Error is trying to push too large Uint8Array ( split it on the higher level )', async t => {
-    const tooLargeSize = 120 * 1024 + 1; // 120KB + 1 byte
-    const largeArray = randomBytesOfLength(tooLargeSize);
-    await t.rejects(endlessVector.push(largeArray), Error, 'expected an Error to be thrown');
+        expect(ev.length).toBe(3);
+        expect(ev.binaryLength).toBe(6 * 1024);
+    }, TX_TIMEOUT);
 });
 
-test('push few Uint8Array in a single transaction block', async t => {
-    const singleItemSize = 40 * 1024; 
-    const largeArray1 = randomBytesOfLength(singleItemSize);
-    const largeArray2 = randomBytesOfLength(singleItemSize);
-    const largeArray3 = randomBytesOfLength(singleItemSize);
-    const tx = new suiMaster.Transaction();
-    await endlessVector.getPushTransaction(largeArray1, tx);
-    await endlessVector.getPushTransaction(largeArray2, tx);
-    await endlessVector.getPushTransaction(largeArray3, tx);
-
-    await suiMaster.signAndExecuteTransaction({
-            transaction: tx,
-            requestType: 'WaitForLocalExecution',
+describe('push and at', () => {
+    let ev;
+
+    it('creates empty EndlessVector', async () => {
+        ev = await createEV();
+        expect(ev).toBeDefined();
+        expect(ev.id).toMatch(/^0x[0-9a-f]+$/);
+        expect(ev.isWritable).toBe(true);
+    }, TX_TIMEOUT);
+
+    it('pushes small Uint8Array and reads it back', async () => {
+        await ev.push(new Uint8Array([1, 2, 3]));
+        const back = await ev.at(0);
+        expect(equalUint8Arrays(back, new Uint8Array([1, 2, 3]))).toBe(true);
+        await ev.initialize();
+        expect(ev.length).toBe(1);
+        expect(ev.binaryLength).toBe(3);
+    }, TX_TIMEOUT);
+
+    it('pushes 30KB array', async () => {
+        const large = randomBytesOfLength(30 * 1024);
+        await ev.push(large);
+        const back = await ev.at(1);
+        expect(equalUint8Arrays(back, large)).toBe(true);
+        expect(ev.length).toBe(2);
+        expect(ev.binaryLength).toBe(3 + 30 * 1024);
+    }, TX_TIMEOUT);
+
+    it('pushes 120KB array', async () => {
+        const large = randomBytesOfLength(120 * 1024);
+        await ev.push(large);
+        const back = await ev.at(2);
+        expect(equalUint8Arrays(back, large)).toBe(true);
+        expect(ev.length).toBe(3);
+        expect(ev.binaryLength).toBe(3 + 30 * 1024 + 120 * 1024);
+    }, TX_TIMEOUT);
+
+    it('rejects arrays larger than 120KB when no walrus is configured', async () => {
+        const evNoWalrus = new EndlessVector({
+            suiClient: suiMaster.client,
+            id: ev.id,
+            packageId,
+            signAndExecuteTransaction: makeSignAndExecute(),
         });
-
-    await endlessVector.reInitialize(); // force re-initialization to load new data
-    const getBack1 = await endlessVector.at(3);
-    const getBack2 = await endlessVector.at(4);
-    const getBack3 = await endlessVector.at(5);
-
-    t.ok(equalUint8Arrays(getBack1, largeArray1));
-    t.ok(getBack1.length === singleItemSize);
-
-    t.ok(equalUint8Arrays(getBack2, largeArray2));
-    t.ok(getBack2.length === singleItemSize);
-
-    t.ok(equalUint8Arrays(getBack3, largeArray3));
-    t.ok(getBack3.length === singleItemSize);
-
-    console.log(endlessVector.length);
-    console.log(endlessVector.binaryLength);
-    t.ok(endlessVector.length === 6);
-    t.ok(endlessVector.binaryLength === 3 + 30*1024 + 120*1024 + 3*singleItemSize);
-});
-
-
-test('test concat functionality', async t => {
-    // Create a second EndlessVector
-    const endlessVector2 = await EndlessVector.create({
-        suiClient: suiMaster.client, // instance of Sui SDK SuiClient
-        packageId: contract.id, // provide packageId and signAndExecuteTransaction to make EndlessVector writable
-        signAndExecuteTransaction: signAndExecuteTransaction,
-    });
-    t.ok(endlessVector2);
-    t.ok(endlessVector2.id);
-
-    // Push some data to the second vector
-    const data1 = new Uint8Array([10, 20, 30]);
-    const data2 = new Uint8Array([40, 50, 60]);
-    await endlessVector2.push(data1);
-    await endlessVector2.push(data2);
-
-    await endlessVector2.initialize();
-    t.ok(endlessVector2.length === 2);
-    t.ok(endlessVector2.binaryLength === 6);
-
-    // Get lengths before concat
-    await endlessVector.initialize();
-    const v1LengthBefore = endlessVector.length;
-    const v1BinaryLengthBefore = endlessVector.binaryLength;
-    const v2Length = endlessVector2.length;
-    const v2BinaryLength = endlessVector2.binaryLength;
-
-    console.log('v1 before concat:', { length: v1LengthBefore, binaryLength: v1BinaryLengthBefore });
-    console.log('v2 before concat:', { length: v2Length, binaryLength: v2BinaryLength });
-
-    // Concat the second vector into the first
-    // Both of these work - passing ID string or EndlessVector instance:
-    // await endlessVector.concat(endlessVector2.id);
-    await endlessVector.concat(endlessVector2);  // Passing EndlessVector instance
-
-    // Verify the first vector now contains both vectors' data
-    await endlessVector.initialize();
-    console.log('v1 after concat:', { length: endlessVector.length, binaryLength: endlessVector.binaryLength });
-
-    t.ok(endlessVector.length === v1LengthBefore + v2Length, 'length should be sum of both vectors');
-    t.ok(endlessVector.binaryLength === v1BinaryLengthBefore + v2BinaryLength, 'binary length should be sum of both vectors');
-
-    // Verify we can access the concatenated data
-    const getBackFromV2_1 = await endlessVector.at(v1LengthBefore);
-    const getBackFromV2_2 = await endlessVector.at(v1LengthBefore + 1);
-
-    t.ok(equalUint8Arrays(getBackFromV2_1, data1), 'first item from v2 should be accessible in v1');
-    t.ok(equalUint8Arrays(getBackFromV2_2, data2), 'second item from v2 should be accessible in v1');
-});
-
-
-test('test concat with array (append)', async t => {
-    // Create three new EndlessVectors
-    const endlessVector3 = await EndlessVector.create({
-        suiClient: suiMaster.client, // instance of Sui SDK SuiClient
-        packageId: contract.id, // provide packageId and signAndExecuteTransaction to make EndlessVector writable
-        signAndExecuteTransaction: signAndExecuteTransaction,
-    });
-    const endlessVector4 = await EndlessVector.create({
-        suiClient: suiMaster.client, // instance of Sui SDK SuiClient
-        packageId: contract.id, // provide packageId and signAndExecuteTransaction to make EndlessVector writable
-        signAndExecuteTransaction: signAndExecuteTransaction,
-    });
-    const endlessVector5 = await EndlessVector.create({
-        suiClient: suiMaster.client, // instance of Sui SDK SuiClient
-        packageId: contract.id, // provide packageId and signAndExecuteTransaction to make EndlessVector writable
-        signAndExecuteTransaction: signAndExecuteTransaction,
+        const tooLarge = randomBytesOfLength(120 * 1024 + 1);
+        await expect(evNoWalrus.push(tooLarge)).rejects.toThrow();
     });
 
-    // Push data to all vectors
-    const data3 = new Uint8Array([100, 101, 102]);
-    const data4 = new Uint8Array([200, 201, 202]);
-    const data5 = new Uint8Array([300, 301, 302]);
+    let walrusLargeData;
 
-    await endlessVector3.push(data3);
-    await endlessVector4.push(data4);
-    await endlessVector5.push(data5);
+    it('auto-routes arrays > 120 KB to walrus when configured', async () => {
+        walrusLargeData = randomBytesOfLength(200 * 1024);
+        const ok = await ev.push(walrusLargeData);
+        expect(ok).toBe(true);
 
-    await endlessVector3.initialize();
-    await endlessVector4.initialize();
-    await endlessVector5.initialize();
+        await ev.initialize();
+        expect(ev.length).toBe(4);
+    }, TX_TIMEOUT);
 
-    const v3Length = endlessVector3.length;
-    const v3BinaryLength = endlessVector3.binaryLength;
-    const v4Length = endlessVector4.length;
-    const v4BinaryLength = endlessVector4.binaryLength;
-    const v5Length = endlessVector5.length;
-    const v5BinaryLength = endlessVector5.binaryLength;
+    it('reads back the walrus-stored item via at()', async () => {
+        const back = await ev.at(3);
+        expect(equalUint8Arrays(back, walrusLargeData)).toBe(true);
+    }, TX_TIMEOUT);
 
-    console.log('Before append:', { v3Length, v4Length, v5Length });
+    it('pushes 3 × 40KB in a single transaction block', async () => {
+        const size = 40 * 1024;
+        const a1 = randomBytesOfLength(size);
+        const a2 = randomBytesOfLength(size);
+        const a3 = randomBytesOfLength(size);
 
-    // Concat with array (append) - passing array of EndlessVector instances
-    await endlessVector3.concat([endlessVector4, endlessVector5]);
+        const tx = new suiMaster.Transaction();
+        ev.getPushTransaction(a1, tx);
+        ev.getPushTransaction(a2, tx);
+        ev.getPushTransaction(a3, tx);
 
-    await endlessVector3.initialize();
-    console.log('After append:', { length: endlessVector3.length, binaryLength: endlessVector3.binaryLength });
-
-    t.ok(endlessVector3.length === v3Length + v4Length + v5Length, 'length should be sum of all vectors');
-    t.ok(endlessVector3.binaryLength === v3BinaryLength + v4BinaryLength + v5BinaryLength, 'binary length should be sum of all vectors');
+        await suiMaster.signAndExecuteTransaction({
+            transaction: tx,
+            requestType: 'WaitForLocalExecution',
+        });
 
-    // Verify data integrity
-    const retrieved3 = await endlessVector3.at(0);
-    const retrieved4 = await endlessVector3.at(1);
-    const retrieved5 = await endlessVector3.at(2);
+        await ev.reInitialize();
+        await ev.initialize();
 
-    t.ok(equalUint8Arrays(retrieved3, data3), 'v3 data should match');
-    t.ok(equalUint8Arrays(retrieved4, data4), 'v4 data should match');
-    t.ok(equalUint8Arrays(retrieved5, data5), 'v5 data should match');
+        expect(equalUint8Arrays(await ev.at(4), a1)).toBe(true);
+        expect(equalUint8Arrays(await ev.at(5), a2)).toBe(true);
+        expect(equalUint8Arrays(await ev.at(6), a3)).toBe(true);
+        expect(ev.length).toBe(7);
+        expect(ev.binaryLength).toBe(3 + 30 * 1024 + 120 * 1024 + 200 * 1024 + 3 * size);
+    }, TX_TIMEOUT);
 });
 
+describe('concat', () => {
+    it('appends a second vector into the first and verifies data', async () => {
+        const ev1 = await createEV();
+        const ev2 = await createEV();
 
-test('test concat large EndlessVectors', async t => {
-    // Create three new EndlessVectors
-    const endlessVectorMain = await EndlessVector.create({
-        suiClient: suiMaster.client, // instance of Sui SDK SuiClient
-        packageId: contract.id, // provide packageId and signAndExecuteTransaction to make EndlessVector writable
-        signAndExecuteTransaction: signAndExecuteTransaction,
-    });
-    const endlessVectorSecond = await EndlessVector.create({
-        suiClient: suiMaster.client, // instance of Sui SDK SuiClient
-        packageId: contract.id, // provide packageId and signAndExecuteTransaction to make EndlessVector writable
-        signAndExecuteTransaction: signAndExecuteTransaction,
-    });
+        const d1 = new Uint8Array([10, 20, 30]);
+        const d2 = new Uint8Array([40, 50, 60]);
+        await ev2.push(d1);
+        await ev2.push(d2);
 
-    const data = [
-    ];
+        await ev2.initialize();
+        expect(ev2.length).toBe(2);
 
-    for (let i = 0; i < 33; i++) {
-        let toMain = randomBytesOfLength(0 + Math.floor(1024 + 50 * 1024 * Math.random())); // 1KB - 50KB
-        if (Math.random() < 0.2) {
-            toMain = new Uint8Array([]); // 20% chance to push empty array
-        }
+        await ev1.initialize();
+        const len1Before = ev1.length;
+        const binLen1Before = ev1.binaryLength;
 
-        data.push(toMain);
-    }
+        await ev1.concat(ev2);
+        await ev1.initialize();
 
-    for (const item of data) {
-        await endlessVectorMain.push(item);
-    }
+        expect(ev1.length).toBe(len1Before + 2);
+        expect(ev1.binaryLength).toBe(binLen1Before + 6);
 
-    for (let i = 0; i < 33; i++) {
-        let toSecond = randomBytesOfLength(0 + Math.floor(1024 + 50 * 1024 * Math.random())); // 1KB - 50KB
-        if (Math.random() < 0.2) {
-            toSecond = new Uint8Array([]); // 20% chance to push empty array
-        }
-        
-        await endlessVectorSecond.push(toSecond);
-        data.push(toSecond);
-    }
+        expect(equalUint8Arrays(await ev1.at(len1Before), d1)).toBe(true);
+        expect(equalUint8Arrays(await ev1.at(len1Before + 1), d2)).toBe(true);
+    }, TX_TIMEOUT);
 
-    await endlessVectorMain.concat(endlessVectorSecond);
+    it('appends array of vectors via concat([...])', async () => {
+        const ev3 = await createEV();
+        const ev4 = await createEV();
+        const ev5 = await createEV();
 
-    await endlessVectorMain.initialize();
+        const d3 = new Uint8Array([100, 101, 102]);
+        const d4 = new Uint8Array([200, 201, 202]);
+        const d5 = new Uint8Array([44, 55, 66]);
 
-    t.ok(endlessVectorMain.length === data.length, 'length should be sum of both vectors');
+        await ev3.push(d3);
+        await ev4.push(d4);
+        await ev5.push(d5);
 
-    // Verify data integrity
-    for (let i = 0; i < data.length; i++) {
-        const retrieved = await endlessVectorMain.at(i);
-        t.ok(equalUint8Arrays(retrieved, data[i]), `data at index ${i} should match`);
-    }
-});
+        await ev3.initialize();
+        await ev4.initialize();
+        await ev5.initialize();
 
+        const len3 = ev3.length;
+        const bin3 = ev3.binaryLength;
 
-test('test parallel creation, push, and append of 6 vectors', async t => {
-    const vectorCount = 6;
+        await ev3.concat([ev4, ev5]);
+        await ev3.initialize();
 
-    // Split gas into at least N coins to use them in parallel transactions
-    const splitTx = new suiMaster.Transaction();
-    for (let i = 0; i < vectorCount; i++) {
-        let coin = splitTx.splitCoins(splitTx.gas, [splitTx.pure.u64(BigInt(1000000000))]);
-        splitTx.transferObjects([coin], splitTx.pure.address(suiMaster.address));
-    }
-    await suiMaster.signAndExecuteTransaction({
-        transaction: splitTx,
-        requestType: 'WaitForLocalExecution',
-    });
+        expect(ev3.length).toBe(len3 + 2);
+        expect(ev3.binaryLength).toBe(bin3 + 6);
 
-    // Get gas coins and prepare inputs for tx.setGasPayment(...);
-    const gasCoins = await suiMaster.client.getCoins({
-        owner: suiMaster.address,
-        coinType: '0x2::sui::SUI',
-    });
-    const gasCoinInputs = gasCoins.data.map((c) => { 
-			return {
-				objectId: c.coinObjectId,
-				digest: c.digest,
-				version: c.version,
-			};
-		});
-
-    t.ok(gasCoinInputs.length >= vectorCount, `should have at least ${vectorCount} gas coins for parallel vector creation.`);
-
-    // Prepare test data for each vector
-    const testData = [];
-    for (let i = 0; i < vectorCount; i++) {
-        testData.push(randomBytesOfLength(1024));
-    }
-
-    // Create N EndlessVectors in parallel using static create method
-    const createPromises = [];
-    for (let i = 0; i < vectorCount; i++) {
-        createPromises.push(
-            EndlessVector.create({
-                suiClient: suiMaster.client,
-                packageId: contract.id,
-                array: testData[i] ? testData[i] : null,
-                gasCoin: gasCoinInputs[i],
-                signAndExecuteTransaction: async (tx) => {
-                    console.log(`Creating vector ${i}...`);
-                    try {
-                        const results = await suiMaster.signAndExecuteTransaction({
-                            transaction: tx,
-                        });
-                        return results.digest;
-                    } catch (e) {
-                        console.error(`Error creating vector ${i}:`, e);
-                    }
-                },
-            })
-        );
-    }
+        expect(equalUint8Arrays(await ev3.at(0), d3)).toBe(true);
+        expect(equalUint8Arrays(await ev3.at(1), d4)).toBe(true);
+        expect(equalUint8Arrays(await ev3.at(2), d5)).toBe(true);
+    }, TX_TIMEOUT);
+});
 
-    const vectors = await Promise.all(createPromises);
-    vectors.forEach((v, i) => {
-        console.log(`Created vector ${i} with id: ${v.id}`);
-    });
+describe('parallel creation and append', () => {
+    it('creates 6 vectors in parallel and concatenates them', async () => {
+        const vectorCount = 6;
 
-    t.ok(vectors.length === vectorCount, `should have created ${vectorCount} vectors`);
+        const splitTx = new suiMaster.Transaction();
+        for (let i = 0; i < vectorCount; i++) {
+            let coin = splitTx.splitCoins(splitTx.gas, [splitTx.pure.u64(BigInt(1000000000))]);
+            splitTx.transferObjects([coin], splitTx.pure.address(suiMaster.address));
+        }
+        await suiMaster.signAndExecuteTransaction({
+            transaction: splitTx,
+            requestType: 'WaitForLocalExecution',
+        });
 
-    const ids = {};
-    vectors.forEach((v, i) => {
-        t.ok(v.id, `vector ${i} should have an id`);
-        t.ok(!ids[v.id], `vector id ${v.id} should be unique`);
-        ids[v.id] = i;
-    });
+        const testData = Array.from({ length: vectorCount }, () => randomBytesOfLength(1024));
 
-    const mainVector = vectors[0];
-    // append other vectors to the first one
-    const vectorsToAppend = vectors.slice(1);
-    await mainVector.concat(vectorsToAppend);
+        const gasCoinsResponse = await suiMaster.client.listCoins({
+            owner: suiMaster.address,
+            coinType: '0x2::sui::SUI',
+        });
+        const gasCoinInputs = gasCoinsResponse.objects.map((c) => ({
+            objectId: c.objectId,
+            digest: c.digest,
+            version: c.version,
+        }));
+
+        const createPromises = [];
+        for (let i = 0; i < vectorCount; i++) {
+            createPromises.push(
+                EndlessVector.create({
+                    suiClient: suiMaster.client,
+                    packageId,
+                    array: testData[i] ?? null,
+                    gasCoin: gasCoinInputs[i],
+                    signAndExecuteTransaction: makeSignAndExecute(),
+                })
+            );
+        }
 
-    // Verify the data after concatenation
-    await mainVector.initialize();
+        const vectors = await Promise.all(createPromises);
 
-    const expectedLength = vectorCount;
-    t.ok(mainVector.length === expectedLength, `mainVector should have ${expectedLength} items, got ${mainVector.length}`);
+        expect(vectors).toHaveLength(vectorCount);
+        vectors.forEach((v, i) => {
+            expect(v.id).toMatch(/^0x[0-9a-f]+$/);
+            console.log(`vector ${i}: ${v.id}`);
+        });
 
-    console.log(`Verifying ${expectedLength} items in concatenated vector...`);
+        const main = vectors[0];
+        await main.concat(vectors.slice(1));
+        await main.initialize();
 
-    // Verify each item matches the original testData
-    for (let vectorIdx = 0; vectorIdx < vectorCount; vectorIdx++) {
-        const expected = testData[vectorIdx];
-        const retrieved = await mainVector.at(vectorIdx);
+        expect(main.length).toBe(vectorCount);
 
-        t.ok(
-            equalUint8Arrays(retrieved, expected),
-            `Item ${vectorIdx} (vector ${vectorIdx}, item ${vectorIdx}) should match`
-        );
-    }
+        for (let i = 0; i < vectorCount; i++) {
+            const back = await main.at(i);
+            expect(equalUint8Arrays(back, testData[i])).toBe(true);
+        }
+    }, 300_000);
 });
 
-test('stops local test node', async t => {
-    await SuiLocalTestValidator.stop();
-});
+describe('archive', () => {
+    it('archives history and data remains readable', async () => {
+        const data = [
+            randomBytesOfLength(1 * 1024),
+            randomBytesOfLength(2 * 1024),
+            randomBytesOfLength(3 * 1024),
+        ];
+
+        const ev = await createEV(data);
+        await ev.initialize();
+
+        const lengthBefore = ev.length;
+        const binLengthBefore = ev.binaryLength;
+        expect(lengthBefore).toBe(3);
+
+        const extra = randomBytesOfLength(120 * 1024);
+        await ev.push(extra);
+
+        await ev.archive();
+        await ev.initialize();
+
+        expect(ev.length).toBe(4);
+        expect(ev.binaryLength).toBe(binLengthBefore + 120 * 1024);
+        expect(ev.archiveItemsCount).toBe(1);
+        expect(ev.archivedAtLength).toBe(4);
+        expect(ev.historyItemsCount).toBe(0);
+        expect(ev.burnedArchiveCount).toBe(0);
+
+        expect(equalUint8Arrays(await ev.at(0), data[0])).toBe(true);
+        expect(equalUint8Arrays(await ev.at(1), data[1])).toBe(true);
+        expect(equalUint8Arrays(await ev.at(2), data[2])).toBe(true);
+        expect(equalUint8Arrays(await ev.at(3), extra)).toBe(true);
+
+        const afterArchive = randomBytesOfLength(4 * 1024);
+        await ev.push(afterArchive);
+        await ev.initialize();
+
+        expect(ev.length).toBe(5);
+        expect(equalUint8Arrays(await ev.at(4), afterArchive)).toBe(true);
+        expect(equalUint8Arrays(await ev.at(0), data[0])).toBe(true);
+        expect(equalUint8Arrays(await ev.at(3), extra)).toBe(true);
+
+        await ev.burnArchive();
+        await ev.initialize();
+
+        expect(ev.burnedArchiveCount).toBe(1);
+        expect(ev.archivedFromLength).toBe(4);
+        expect(ev.length).toBe(5);
+
+        expect(equalUint8Arrays(await ev.at(4), afterArchive)).toBe(true);
+
+        await expect(ev.at(0)).rejects.toThrow();
+        await expect(ev.at(1)).rejects.toThrow();
+        await expect(ev.at(2)).rejects.toThrow();
+        await expect(ev.at(3)).rejects.toThrow();
+    }, TX_TIMEOUT);
+
+    it('multiple archive/burn cycles accumulate archivedFromLength correctly', async () => {
+        const ev = await createEV();
+
+        const batch1 = randomBytesOfLength(120 * 1024);
+        await ev.push(batch1);
+        await ev.archive();
+        await ev.initialize();
+        expect(ev.archiveItemsCount).toBe(1);
+        expect(ev.archivedAtLength).toBe(1);
+
+        const batch2 = randomBytesOfLength(120 * 1024);
+        await ev.push(batch2);
+        await ev.archive();
+        await ev.initialize();
+        expect(ev.archiveItemsCount).toBe(2);
+        expect(ev.archivedAtLength).toBe(2);
+
+        expect(equalUint8Arrays(await ev.at(0), batch1)).toBe(true);
+        expect(equalUint8Arrays(await ev.at(1), batch2)).toBe(true);
+
+        await ev.burnArchive();
+        await ev.initialize();
+        expect(ev.burnedArchiveCount).toBe(1);
+        expect(ev.archivedFromLength).toBe(1);
+
+        await expect(ev.at(0)).rejects.toThrow();
+        expect(equalUint8Arrays(await ev.at(1), batch2)).toBe(true);
+
+        await ev.burnArchive();
+        await ev.initialize();
+        expect(ev.burnedArchiveCount).toBe(2);
+        expect(ev.archivedFromLength).toBe(2);
+
+        await expect(ev.at(1)).rejects.toThrow();
+    }, TX_TIMEOUT);
+
+    it('re-reading vector by ID after archive and burn reflects correct state', async () => {
+        const ev = await createEV();
+        const item = randomBytesOfLength(120 * 1024);
+        await ev.push(item);
+        await ev.archive();
+        await ev.burnArchive();
+
+        const fresh = makeEV(ev.id);
+        await fresh.initialize();
+
+        expect(fresh.burnedArchiveCount).toBe(1);
+        expect(fresh.archivedFromLength).toBe(1);
+        expect(fresh.length).toBe(1);
+        await expect(fresh.at(0)).rejects.toThrow();
+    }, TX_TIMEOUT);
+
+    it('concat rejects a source vector that has archived items', async () => {
+        const src = await createEV();
+        const dst = await createEV();
+
+        const item = randomBytesOfLength(120 * 1024);
+        await src.push(item);
+        await src.archive();
+        await src.initialize();
+        expect(src.archiveItemsCount).toBeGreaterThan(0);
+
+        await expect(dst.concat(src)).rejects.toThrow();
+    }, TX_TIMEOUT);
+});