@fizzyflow/endless-vector 0.0.8 → 0.0.10

package/EndlessVector.js

@@ -1,13 +1,16 @@
 import EndlessVectorHistory from './EndlessVectorHistory.js';
 import EndlessVectorArchive from './EndlessVectorArchive.js';
+import EndlessVectorItem from './EndlessVectorItem.js';
+import EndlessVectorWalrus from './EndlessVectorWalrus.js';
+import EndlessVectorSeal from './EndlessVectorSeal.js';
 import { Transaction } from '@mysten/sui/transactions';
 import { bcs } from '@mysten/sui/bcs';
 import ids from './ids.js';
 
+
+
 /**
- * @typedef {import('@mysten/sui/client').SuiClient} SuiClient
- * @typedef {import('@mysten/sui/client').GetObjectParams} GetObjectParams
- * @typedef {import('@mysten/sui/client').GetDynamicFieldsParams} GetDynamicFieldsParams
+ * @typedef {import('@mysten/sui/grpc').SuiGrpcClient} SuiGrpcClient
  * @typedef {import('@mysten/sui/transactions').TransactionResult} TransactionResult
  */
 
@@ -27,14 +30,21 @@ export default class EndlessVector {
     /**
      * Creates a new EndlessVector instance.
      * @param {Object} params - Configuration parameters
-     * @param {SuiClient} [params.suiClient] - Sui client instance for blockchain interactions
+     * @param {SuiGrpcClient} [params.suiClient] - gRPC client instance for blockchain interactions
      * @param {string} [params.id] - ID or address of the EndlessVector on the Sui blockchain
-     *
-     * @param {?string} [params.packageId] - Adds write capability if provided, ID of the Move package containing the EndlessVector module or 'mainnet', 'testnet' to use known IDs
-     * @param {?CustomSignAndExecuteTransactionFunction} [params.signAndExecuteTransaction] - Adds write capability if provided, function should accept Sui transaction, sign and submit it to the blockchain and return its digest
+     * @param {?string} [params.packageId] - Adds write capability if provided; ID of the Move package or 'mainnet'/'testnet' to use known IDs
+     * @param {?CustomSignAndExecuteTransactionFunction} [params.signAndExecuteTransaction] - Adds write capability if provided; must accept a Transaction and return its digest
+     * @param {?import('@mysten/walrus').WalrusClient} [params.walrusClient] - Walrus client for blob reads and writes (preferred)
+     * @param {?string} [params.publisherUrl] - Walrus publisher HTTP URL for blob uploads (fallback if no walrusClient)
+     * @param {?string} [params.aggregatorUrl] - Walrus aggregator HTTP URL for blob reads (fallback if no walrusClient)
+     * @param {?string} [params.senderAddress] - Sui address of the transaction sender, required for Walrus blob writes
+     * @param {?import('@mysten/seal').SealClient} [params.sealClient] - SealClient for Seal encryption/decryption
+     * @param {?import('@mysten/seal').SessionKey} [params.sessionKey] - Pre-built SessionKey for Seal operations
+     * @param {?any} [params.signer] - Keypair/signer to mint a SessionKey when needed
+     * @param {?number} [params.sealTtlMin=5] - SessionKey TTL in minutes (default: 5)
      */
     constructor(params = {}) {
-        /** @type {SuiClient} */
+        /** @type {SuiGrpcClient} */
         this.suiClient = params.suiClient;
         /** @type {string} */
         this.id = params.id;
@@ -54,7 +64,7 @@ export default class EndlessVector {
         /** @type {boolean} */
         this.firstItemIsFromPreviousHistory = false; // from EndlessVector.fields.
 
-        /** @type {Array<Uint8Array>} */
+        /** @type {Array<EndlessVectorItem>} */
         this._items = []; // items in current EndlessVector object,
 
         /** @type {string} */
@@ -85,6 +95,40 @@ export default class EndlessVector {
 
         /** @type {?CustomSignAndExecuteTransactionFunction} */
         this._signAndExecuteTransaction = params.signAndExecuteTransaction || null;
+
+        /**
+         * EndlessVectorWalrus instance for Walrus blob read/write.
+         * Null on plain EndlessVector; set to `this` by EndlessVectorWalrus constructor.
+         * @type {?EndlessVectorWalrus}
+         */
+        this.walrus = new EndlessVectorWalrus({ ...params, endlessVector: this });
+
+        /**
+         * EndlessVectorSeal companion. Always present; only "enabled" when sealClient is supplied.
+         * @type {EndlessVectorSeal}
+         */
+        this.seal = new EndlessVectorSeal({ ...params, endlessVector: this });
+
+        /**
+         * Raw seal_encrypted_key bytes loaded from the on-chain object during initialize().
+         * `null` for unsealed vectors. SDK callers usually don't need to read this directly.
+         * @type {?Uint8Array}
+         */
+        this.sealEncryptedKey = null;
+    }
+
+    get packageId() {
+        return this._packageId;
+    }
+
+    static getPackageId(network) {
+        const entry = ids[network];
+        return entry ? entry.packageId : null;
+    }
+
+    async isEncrypted() {
+        await this.initialize();
+        return !!this.sealEncryptedKey;
     }
 
     /**
@@ -92,7 +136,7 @@ export default class EndlessVector {
      * Creates a new EndlessVector object via the Move contract and returns a wrapped instance.
      *
      * @param {Object} params - Configuration parameters
-     * @param {SuiClient} params.suiClient - Sui client instance for blockchain interactions
+     * @param {SuiGrpcClient} params.suiClient - Sui gRPC client instance for blockchain interactions
      * @param {string} params.packageId - ID of the Move package containing the EndlessVector module
      * @param {CustomSignAndExecuteTransactionFunction} params.signAndExecuteTransaction - Function to sign and execute transactions
      * @param {?Uint8Array|Uint8Array[]} [params.array] - Optional Uint8Array to initialize the vector with as the first item to get with .at(0)
@@ -124,20 +168,31 @@ export default class EndlessVector {
         }
 
         // Create transaction to call empty_entry
+        // Sealed mode requires the vector id (only known after the first tx) to scope the
+        // Seal-encrypted AES key. We thus:
+        //   tx 1 — create an empty vector
+        //   tx 2 — set_seal_encrypted_key
+        //   tx 3+ — push initial `array` items (encrypted) via the normal push() path
+        // Unsealed mode keeps the single-tx fast path below unchanged.
+        const sealRequested = !!params.sealClient;
+        const sealItemsToPush = sealRequested ? array : null;
+        const useArray = sealRequested ? null : array;
+
         const tx = new Transaction();
 
         if (gasCoin) {
             tx.setGasPayment([gasCoin]);
         }
 
-        if (array && array.length) {
+        if (useArray && useArray.length) {
+            const array = useArray;
             if ((array instanceof Uint8Array)) {
                 // single chunk
                 const vectorInput = await EndlessVector.getCreateTransactionAndReturnVectorInput({
                     packageId: normalizedPackageId,
                 }, array, tx);
                 tx.moveCall({
-                    target: `${normalizedPackageId}::endless_vector::transfer_to_sender`,
+                    target: `${normalizedPackageId}::endless_walrus::transfer_to_sender`,
                     arguments: [vectorInput],
                 });
             } else if (array[0] && (array[0] instanceof Uint8Array)) {
@@ -149,7 +204,7 @@ export default class EndlessVector {
                     EndlessVector.composePushTransaction(normalizedPackageId, vectorInput, array[i], tx);
                 }
                 tx.moveCall({
-                    target: `${normalizedPackageId}::endless_vector::transfer_to_sender`,
+                    target: `${normalizedPackageId}::endless_walrus::transfer_to_sender`,
                     arguments: [vectorInput],
                 });
             } else {
@@ -157,48 +212,76 @@ export default class EndlessVector {
             }
         } else {
             tx.moveCall({
-                target: `${normalizedPackageId}::endless_vector::empty_entry`,
+                target: `${normalizedPackageId}::endless_walrus::empty_entry`,
                 arguments: [],
             });
         }
 
-        // Execute transaction
-        const digest = await signAndExecuteTransaction(tx);
-
-        // Wait for transaction to complete
-        const transactionBlockResponse = await suiClient.waitForTransaction({
-            digest: digest,
+        // Execute transaction — callback may return a digest string OR a rich tx-data object
+        const execResult = await signAndExecuteTransaction(tx);
+        const digest = typeof execResult === 'string'
+            ? execResult
+            : execResult?.digest ?? execResult?.data?.digest;
+        if (!digest) throw new Error('signAndExecuteTransaction returned no digest');
+
+        // create() always needs objectTypes to find the new EndlessVector, which the
+        // callback's effects don't include — so we always do a waitForTransaction here.
+        const txResult = await suiClient.waitForTransaction({
+            digest,
+            include: { effects: true, objectTypes: true },
             timeout: options.timeout || 30000,
-            pollIntervalMs: options.pollIntervalMs || 1000,
-            options: {
-                showEffects: true,
-                showObjectChanges: true,
-            },
+            pollInterval: options.pollIntervalMs || 200,
         });
-
-        if (transactionBlockResponse?.effects?.status?.status !== 'success') {
+        const txData = txResult.Transaction ?? txResult.FailedTransaction;
+        if (!txData?.status?.success) {
             throw new Error('Transaction failed to create EndlessVector');
         }
 
-        // 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')
+        // Find the created EndlessVector object via objectTypes map (gRPC) or fallback objectChanges
+        const objectTypes = txData.objectTypes ?? {};
+        const createdVector = txData.effects?.changedObjects?.find(
+            c => c.idOperation === 'Created' &&
+                 (objectTypes[c.objectId] ?? '').includes('endless_walrus::EndlessWalrusVector')
         );
 
-        if (!createdVector || !createdVector.objectId) {
+        if (!createdVector?.objectId) {
             throw new Error('Failed to find created EndlessVector object in transaction response');
         }
 
-        // Create and return the EndlessVector instance
-        return new EndlessVector({
+        // Create the EndlessVector instance
+        const ev = new EndlessVector({
+            ...params,
             suiClient,
             id: createdVector.objectId,
             packageId: normalizedPackageId,
             signAndExecuteTransaction,
         });
+
+        // Seal layer: generate AES key, Seal-wrap it scoped to the new vector id, attach on-chain.
+        // Subsequent push() calls will encrypt every item automatically.
+        if (sealRequested) {
+            const aesKey = EndlessVectorSeal.generateAesKey();
+            ev.seal.setAesKey(aesKey);
+            const wrappedKey = await ev.seal.wrapAesKey(aesKey);
+
+            const setKeyTx = new Transaction();
+            setKeyTx.moveCall({
+                target: `${normalizedPackageId}::endless_walrus::set_seal_encrypted_key`,
+                arguments: [
+                    setKeyTx.object(ev.id),
+                    setKeyTx.pure(bcs.vector(bcs.u8()).serialize(wrappedKey)),
+                ],
+            });
+            await ev.executeAndWaitForTransaction(setKeyTx, options);
+            ev.sealEncryptedKey = wrappedKey;
+
+            // Now push any initial items — push() will encrypt them transparently.
+            if (sealItemsToPush && sealItemsToPush.length) {
+                await ev.push(sealItemsToPush, options);
+            }
+        }
+
+        return ev;
     }
 
     /**
@@ -248,7 +331,7 @@ export default class EndlessVector {
         }
 
         const vectorInput = tx.moveCall({
-            target: `${normalizedPackageId}::endless_vector::empty`,
+            target: `${normalizedPackageId}::endless_walrus::empty`,
             arguments: [],
         });
 
@@ -263,6 +346,55 @@ export default class EndlessVector {
         return !!(this._packageId && this._signAndExecuteTransaction);
     }
 
+    /**
+     * Executes a transaction via the configured `_signAndExecuteTransaction` callback and
+     * resolves to the tx data containing effects.
+     *
+     * If the callback already returns an object with `.effects` (e.g. callers that use
+     * `WaitForLocalExecution` and pass the full response through), we trust that result
+     * and skip an extra `waitForTransaction` poll round-trip. Otherwise we treat the
+     * return value as a digest string and poll until the tx lands.
+     *
+     * @param {Transaction} tx
+     * @param {Object} [params]
+     * @param {number} [params.timeout=30000]
+     * @param {number} [params.pollIntervalMs=200]
+     * @param {Object} [params.include={ effects: true }]
+     * @returns {Promise<Object>} Resolves to the tx data ({ digest, effects, ... }).
+     * @throws {Error} If the callback returns no digest or the tx failed.
+     */
+    async executeAndWaitForTransaction(tx, params = {}) {
+        const result = await this._signAndExecuteTransaction(tx);
+
+        // Rich return: tx data containing effects is already present. Accept either the raw
+        // tx data ({ digest, effects, status }) or a wrapper exposing effects via `.data`
+        // (e.g. suidouble's SuiTransaction). In either case, skip the extra polling round-trip.
+        if (result && typeof result === 'object') {
+            const txData = result.effects ? result : (result.data?.effects ? result.data : null);
+            if (txData) {
+                if (txData.status && txData.status.success === false) {
+                    throw new Error('Transaction failed');
+                }
+                return txData;
+            }
+        }
+
+        const digest = typeof result === 'string' ? result : result?.digest;
+        if (!digest) throw new Error('signAndExecuteTransaction returned no digest');
+
+        const txResult = await this.suiClient.waitForTransaction({
+            digest,
+            include: params.include ?? { effects: true },
+            timeout: params.timeout || 30000,
+            pollInterval: params.pollIntervalMs || 200,
+        });
+        const txData = txResult.Transaction ?? txResult.FailedTransaction;
+        if (!txData?.status?.success) {
+            throw new Error('Transaction failed');
+        }
+        return txData;
+    }
+
     /** 
      * Attach move calls to transaction, to push item into endlessvector, handling large arrays by chunking them.
      * This static method can be used to compose transactions for any existing EndlessVector instance:
@@ -278,13 +410,13 @@ export default class EndlessVector {
      * @param {Uint8Array} arr - The byte array to push to the vector
      * @param {Transaction} tx - The transaction object to append the move calls to
      * @returns {Transaction} The transaction object with the push operations added
-     * @throws {Error} If the array is larger than 120KB (10 * 12KB)
+     * @throws {Error} If the array is larger than 120KB (10 * 12KB) — callers should use push() which falls back to walrus.pushBlob() automatically
      */
     static composePushTransaction(packageId, vectorInput, arr, tx) {
         const maxArgLength = 12 * 1024;
         if (arr.length <= maxArgLength) {
                 tx.moveCall({
-                        target: `${packageId}::endless_vector::push_back`,
+                        target: `${packageId}::endless_walrus::push_back_bytes`,
                         arguments: [
                             vectorInput,
                             tx.pure(bcs.vector(bcs.u8()).serialize(arr)),
@@ -308,7 +440,7 @@ export default class EndlessVector {
                 args.push(tx.pure(bcs.vector(bcs.u8()).serialize(chunks[i])));
             }
             tx.moveCall({
-                    target: `${packageId}::endless_vector::compose_and_push_back`,
+                    target: `${packageId}::endless_walrus::compose_and_push_back`,
                     arguments: args,
                 });
         } else {
@@ -358,26 +490,38 @@ export default class EndlessVector {
      * @param {Uint8Array|Uint8Array[]} arr - Byte array or array of byte arrays to push
      * @param {?Object} params - Configuration parameters
      * @param {?Number} [params.timeout] - wait for transaction confirmation timeout in ms, default 30000
-     * @param {?Number} [params.pollIntervalMs] - wait for transaction confirmation poll interval in ms, default 1000
+     * @param {?Number} [params.pollIntervalMs] - wait for transaction confirmation poll interval in ms, default 200
      * @return {Promise<boolean>} True if the push was successful
     */
     async push(arr, params = {}) {
         if (!this.isWritable) {
             throw new Error('EndlessVector is not writable, packageId and signAndExecuteTransaction are required');
         }
-        const tx = this.getPushTransaction(arr);
-        const digest = await this._signAndExecuteTransaction(tx);
 
-        const transactionBlockResponse = await this.suiClient.waitForTransaction({
-            digest: digest,
-            timeout: params.timeout || 30000,
-            pollIntervalMs: params.pollIntervalMs || 1000,
-            options: { showEffects: true },
-        });
-        if (transactionBlockResponse?.effects?.status?.status !== 'success') {
-            throw new Error('Transaction failed');
+        // When the vector is sealed, transparently encrypt every item before it goes on-chain.
+        // Encryption adds 28 bytes (12B nonce + 16B tag), so it can shift items across the
+        // 120 KB walrus threshold — encrypt first, then route.
+        if (this.sealEncryptedKey && this.seal?.isEnabled) {
+            if (arr instanceof Uint8Array) {
+                arr = await this.seal.encryptItem(arr);
+            } else if (Array.isArray(arr)) {
+                const encrypted = [];
+                for (const item of arr) encrypted.push(await this.seal.encryptItem(item));
+                arr = encrypted;
+            }
+        }
+
+        const maxBytesPerTx = 10 * 12 * 1024;
+        if (arr instanceof Uint8Array && arr.length > maxBytesPerTx) {
+            if (!this.walrus) {
+                throw new Error('Array too large for a single tx and no Walrus client configured');
+            }
+            return !!(await this.walrus.pushBlob(arr, params));
         }
 
+        const tx = this.getPushTransaction(arr);
+        await this.executeAndWaitForTransaction(tx, params);
+
         this.reInitialize(); // force re-initialization to load new data
 
         return true;
@@ -414,7 +558,7 @@ export default class EndlessVector {
             const objectRefs = otherIds.map(id => tx.object(id));
 
             tx.moveCall({
-                target: `${this._packageId}::endless_vector::append`,
+                target: `${this._packageId}::endless_walrus::append`,
                 arguments: [
                     tx.object(this.id),
                     tx.makeMoveVec({ elements: objectRefs }),
@@ -425,7 +569,7 @@ export default class EndlessVector {
             const otherEndlessVectorId = (typeof other === 'object' && other.id) ? other.id : other;
 
             tx.moveCall({
-                target: `${this._packageId}::endless_vector::concat`,
+                target: `${this._packageId}::endless_walrus::concat`,
                 arguments: [
                     tx.object(this.id),
                     tx.object(otherEndlessVectorId),
@@ -444,7 +588,7 @@ export default class EndlessVector {
      * @param {string|EndlessVector|Array<string|EndlessVector>} other - The ID of the EndlessVector to concatenate, an EndlessVector instance, or an array of IDs/instances to append
      * @param {?Object} params - Configuration parameters
      * @param {?Number} [params.timeout] - wait for transaction confirmation timeout in ms, default 30000
-     * @param {?Number} [params.pollIntervalMs] - wait for transaction confirmation poll interval in ms, default 1000
+     * @param {?Number} [params.pollIntervalMs] - wait for transaction confirmation poll interval in ms, default 200
      * @return {Promise<boolean>} True if the concat was successful
      * @throws {Error} If the instance is not writable, if the transaction fails, or if any vector has archived items
     */
@@ -453,20 +597,112 @@ export default class EndlessVector {
             throw new Error('EndlessVector is not writable, packageId and signAndExecuteTransaction are required');
         }
 
+        // Sealed vectors hold items encrypted under per-vector AES keys; merging two would
+        // require re-encrypting every item under one key. Refuse early.
+        if (this.sealEncryptedKey) {
+            throw new Error('concat is not supported on sealed vectors');
+        }
+
         const tx = this.getConcatTransaction(other);
-        const digest = await this._signAndExecuteTransaction(tx);
+        await this.executeAndWaitForTransaction(tx, params);
 
-        const transactionBlockResponse = await this.suiClient.waitForTransaction({
-            digest: digest,
-            timeout: params.timeout || 30000,
-            pollIntervalMs: params.pollIntervalMs || 1000,
-            options: { showEffects: true },
+        this.reInitialize(); // force re-initialization to load new data
+
+        return true;
+    }
+
+    /**
+     * Creates a transaction to archive the current history of this EndlessVector.
+     * Moves all history items into a new archive entry, freeing up history capacity.
+     * Note: this method only creates the transaction, it does not sign or execute it.
+     *
+     * @param {Transaction} [txToAppendTo=null] - Optional transaction to append to
+     * @returns {Transaction} The transaction object to be signed and executed
+     * @throws {Error} If packageId is not set
+     */
+    getArchiveTransaction(txToAppendTo = null) {
+        if (!this._packageId) {
+            throw new Error('packageId is required to compose archive transaction');
+        }
+
+        const tx = txToAppendTo ?? new Transaction();
+
+        tx.moveCall({
+            target: `${this._packageId}::endless_walrus::archive`,
+            arguments: [tx.object(this.id)],
         });
-        if (transactionBlockResponse?.effects?.status?.status !== 'success') {
-            throw new Error('Transaction failed');
+
+        return tx;
+    }
+
+    /**
+     * Archives the current history of this EndlessVector, creating and executing the necessary transaction.
+     * Moves all history items into a new archive entry to free up history capacity for future pushes.
+     * Requires the instance to be writable (packageId and signAndExecuteTransaction must be provided).
+     *
+     * @param {?Object} params - Configuration parameters
+     * @param {?Number} [params.timeout] - wait for transaction confirmation timeout in ms, default 30000
+     * @param {?Number} [params.pollIntervalMs] - wait for transaction confirmation poll interval in ms, default 200
+     * @returns {Promise<boolean>} True if the archive was successful
+     * @throws {Error} If the instance is not writable or if the transaction fails
+     */
+    async archive(params = {}) {
+        if (!this.isWritable) {
+            throw new Error('EndlessVector is not writable, packageId and signAndExecuteTransaction are required');
         }
 
-        this.reInitialize(); // force re-initialization to load new data
+        const tx = this.getArchiveTransaction();
+        await this.executeAndWaitForTransaction(tx, params);
+
+        this.reInitialize();
+
+        return true;
+    }
+
+    /**
+     * Creates a transaction to burn the oldest archive entry of this EndlessVector.
+     * Burned items are permanently deleted and can no longer be read.
+     * Note: this method only creates the transaction, it does not sign or execute it.
+     *
+     * @param {Transaction} [txToAppendTo=null] - Optional transaction to append to
+     * @returns {Transaction} The transaction object to be signed and executed
+     * @throws {Error} If packageId is not set
+     */
+    getBurnArchiveTransaction(txToAppendTo = null) {
+        if (!this._packageId) {
+            throw new Error('packageId is required to compose burn_archive transaction');
+        }
+
+        const tx = txToAppendTo ?? new Transaction();
+
+        tx.moveCall({
+            target: `${this._packageId}::endless_walrus::burn_archive`,
+            arguments: [tx.object(this.id)],
+        });
+
+        return tx;
+    }
+
+    /**
+     * Burns the oldest archive entry of this EndlessVector, creating and executing the necessary transaction.
+     * Burned items are permanently deleted and can no longer be read.
+     * Requires the instance to be writable (packageId and signAndExecuteTransaction must be provided).
+     *
+     * @param {?Object} params - Configuration parameters
+     * @param {?Number} [params.timeout] - wait for transaction confirmation timeout in ms, default 30000
+     * @param {?Number} [params.pollIntervalMs] - wait for transaction confirmation poll interval in ms, default 200
+     * @returns {Promise<boolean>} True if the burn was successful
+     * @throws {Error} If the instance is not writable or if the transaction fails
+     */
+    async burnArchive(params = {}) {
+        if (!this.isWritable) {
+            throw new Error('EndlessVector is not writable, packageId and signAndExecuteTransaction are required');
+        }
+
+        const tx = this.getBurnArchiveTransaction();
+        await this.executeAndWaitForTransaction(tx, params);
+
+        this.reInitialize();
 
         return true;
     }
@@ -521,15 +757,8 @@ export default class EndlessVector {
         this.__initializationPromiseResolver = null;
         this.__initializationPromise = new Promise((res)=>{ this.__initializationPromiseResolver = res; });
 
-        /** @type {GetObjectParams} */
-        const getObjectParams = {
-            id: this.id,
-            options: {
-                showContent: true,
-            },
-        };
-        const endlessVectorObjectResponse = await this.suiClient.getObject(getObjectParams);
-        const endlessVectorObject = endlessVectorObjectResponse.data?.content?.fields;
+        const { object } = await this.suiClient.getObject({ objectId: this.id, include: { json: true } });
+        const endlessVectorObject = object?.json;
 
         this.binaryLength = parseInt(endlessVectorObject?.binary_length || 0);
         this.length = parseInt(endlessVectorObject?.length || 0);
@@ -544,12 +773,17 @@ export default class EndlessVector {
         this._items = [];
         if (endlessVectorObject?.items && endlessVectorObject.items.length) {
             for (const item of endlessVectorObject.items) {
-                this._items.push(new Uint8Array(item));
+                this._items.push(EndlessVectorItem.fromGrpcJson(item, { endlessVector: this }));
             }
         }
 
-        this.archiveTableId = endlessVectorObject?.archive?.fields?.id?.id;
-        this.historyTableId = endlessVectorObject?.history?.fields?.id?.id;
+        // In gRPC json, Table<K,V> appears as { id: "0x...", size: "..." } — id is a plain string
+        this.archiveTableId = endlessVectorObject?.archive?.id;
+        this.historyTableId = endlessVectorObject?.history?.id;
+
+        // seal_encrypted_key is an Option<vector<u8>> on-chain.
+        // None → null/undefined; Some(bytes) → base64 string (or array fallback).
+        this.sealEncryptedKey = EndlessVector._decodeOptionVectorU8(endlessVectorObject?.seal_encrypted_key);
 
         this._isInitialized = true;
         this.__initializationPromiseResolver();
@@ -581,27 +815,19 @@ export default class EndlessVector {
             throw new Error('historyTableId is not set');
         }
 
-        /** @type {GetDynamicFieldsParams} */
-        const getDynamicFieldsParams  = {
-            parentId: this.historyTableId,
-            options: {
-                showContent: true,
-                showType: true,
-            },
-        };
-
+        let cursor = undefined;
         let resp = null;
         let haveToLookMore = true;
 
         do {
-            resp  = await this.suiClient.getDynamicFields(getDynamicFieldsParams);
-            if (resp && resp.data && resp.data.length) {
-                for (const df of resp.data) {
-                    if (df?.objectId) {
-                        const itemHistoryIndex = parseInt(df.name.value);
+            resp = await this.suiClient.listDynamicFields({ parentId: this.historyTableId, cursor });
+            if (resp?.dynamicFields?.length) {
+                for (const df of resp.dynamicFields) {
+                    if (df.fieldId) {
+                        const itemHistoryIndex = EndlessVector._decodeBcsU64(df.name.bcs);
                         const endlessVectorHistory = new EndlessVectorHistory({
                             suiClient: this.suiClient,
-                            id: df.objectId,
+                            id: df.fieldId,
                             index: itemHistoryIndex,
                             endlessVector: this,
                         });
@@ -611,7 +837,7 @@ export default class EndlessVector {
                         }
                     }
                 }
-                getDynamicFieldsParams.cursor = resp.nextCursor;
+                cursor = resp.cursor;
             }
         } while (resp?.hasNextPage && haveToLookMore);
 
@@ -644,27 +870,19 @@ export default class EndlessVector {
             throw new Error('archiveTableId is not set');
         }
 
-        /** @type {GetDynamicFieldsParams} */
-        const getDynamicFieldsParams  = {
-            parentId: this.archiveTableId,
-            options: {
-                showContent: true,
-                showType: true,
-            },
-        };
-
+        let cursor = undefined;
         let resp = null;
         let haveToLookMore = true;
 
         do {
-            resp  = await this.suiClient.getDynamicFields(getDynamicFieldsParams);
-            if (resp && resp.data && resp.data.length) {
-                for (const df of resp.data) {
-                    if (df?.objectId) {
-                        const itemArchiveIndex = parseInt(df.name.value);
+            resp = await this.suiClient.listDynamicFields({ parentId: this.archiveTableId, cursor });
+            if (resp?.dynamicFields?.length) {
+                for (const df of resp.dynamicFields) {
+                    if (df.fieldId) {
+                        const itemArchiveIndex = EndlessVector._decodeBcsU64(df.name.bcs);
                         const endlessVectorArchive = new EndlessVectorArchive({
                             suiClient: this.suiClient,
-                            id: df.objectId,
+                            id: df.fieldId,
                             index: itemArchiveIndex,
                             endlessVector: this,
                         });
@@ -674,7 +892,7 @@ export default class EndlessVector {
                         }
                     }
                 }
-                getDynamicFieldsParams.cursor = resp.nextCursor;
+                cursor = resp.cursor;
             }
         } while (resp?.hasNextPage && haveToLookMore);
 
@@ -695,27 +913,24 @@ export default class EndlessVector {
      */
     async loadHistoryItemsBunch(historyItems) {
         const ids = historyItems.map(hi => hi.id);
-        let results = [];
+        let objects = [];
         try {
-            results = await this.suiClient.multiGetObjects({
-                ids: ids,
-                options: { showContent: true,  },
-            });
+            const res = await this.suiClient.getObjects({ objectIds: ids, include: { json: true } });
+            objects = res.objects ?? [];
         } catch(e) {
             console.error(e);
         }
 
-        if (results && results.length) {
-            for (const res of results) {
-                const fields = res?.data?.content?.fields?.value?.fields;
-                const id = res?.data?.content?.fields?.id?.id;
+        for (const obj of objects) {
+            // Dynamic field Field<K,V>: json = { id: { id: "..." }, name: K, value: V_fields }
+            const fields = obj?.json?.value;
+            const id = obj?.json?.id?.id ?? obj?.objectId;
 
-                historyItems.forEach(hi => {
-                    if (hi.id === id) {
-                        hi.setFields(fields);
-                    }
-                });
-            }
+            historyItems.forEach(hi => {
+                if (hi.id === id) {
+                    hi.setFields(fields);
+                }
+            });
         }
     }
 
@@ -804,27 +1019,23 @@ export default class EndlessVector {
      */
     async loadArchiveItemsBunch(archiveItems) {
         const ids = archiveItems.map(ai => ai.id);
-        let results = [];
+        let objects = [];
         try {
-            results = await this.suiClient.multiGetObjects({
-                ids: ids,
-                options: { showContent: true,  },
-            });
+            const res = await this.suiClient.getObjects({ objectIds: ids, include: { json: true } });
+            objects = res.objects ?? [];
         } catch(e) {
             console.error(e);
         }
 
-        if (results && results.length) {
-            for (const res of results) {
-                const fields = res?.data?.content?.fields?.value?.fields;
-                const id = res?.data?.content?.fields?.id?.id;
+        for (const obj of objects) {
+            const fields = obj?.json?.value;
+            const id = obj?.json?.id?.id ?? obj?.objectId;
 
-                archiveItems.forEach(ai => {
-                    if (ai.id === id) {
-                        ai.setFields(fields);
-                    }
-                });
-            }
+            archiveItems.forEach(ai => {
+                if (ai.id === id) {
+                    ai.setFields(fields);
+                }
+            });
         }
     }
 
@@ -909,11 +1120,26 @@ export default class EndlessVector {
 
     /**
      * Retrieves the byte array at the specified index from either current items or history.
+     * For sealed vectors, transparently decrypts the item via the seal companion.
      * @param {number} i - The index to retrieve
      * @returns {Promise<Uint8Array>} The byte array at the specified index
      * @throws {Error} If the index is out of range or cannot be found
      */
     async at(i) {
+        const raw = await this._atRaw(i);
+        if (this.sealEncryptedKey) {
+            return await this.seal.decryptItem(raw);
+        }
+        return raw;
+    }
+
+    /**
+     * Raw read of the byte array at the specified index. Returns ciphertext for sealed vectors.
+     * Kept separate so `at()` can wrap with optional decryption without rewriting routing.
+     * @param {number} i
+     * @returns {Promise<Uint8Array>}
+     */
+    async _atRaw(i) {
         await this.initialize();
 
         if (i < 0 || i >= this.length) {
@@ -948,10 +1174,10 @@ export default class EndlessVector {
             // in current items
             if (this.firstItemIsFromPreviousHistory) {
                 const indexInItems = i - this.firstNotHistoryIndex + 1;
-                return this._items[indexInItems];
+                return await this._items[indexInItems].bytes();
             } else {
                 const indexInItems = i - this.firstNotHistoryIndex;
-                return this._items[indexInItems];
+                return await this._items[indexInItems].bytes();
             }
         }
 
@@ -971,11 +1197,44 @@ export default class EndlessVector {
         if (i < this.historyItemsCount) {
             const historyItem = await this.getHistory(i);
             if (historyItem) {
-                return historyItem.getSuffixStoredBytes();
+                return await historyItem.getSuffixStoredBytes();
             }
         } else if (this._history[i - 1] && this.firstItemIsFromPreviousHistory) {
-            // if there is no such history item, but previous exists, then suffix is the first item of the EndlessVector object items itself 
-            return this._items[0];
+            // if there is no such history item, but previous exists, then suffix is the first item of the EndlessVector object items itself
+            return await this._items[0].bytes();
         }
     }
+
+    /**
+     * Decode a little-endian u64 from a BCS-encoded Uint8Array (gRPC dynamic-field name).
+     * @param {Uint8Array} bcsBytes
+     * @returns {number}
+     */
+    /**
+     * Decode a (possibly-Option) `vector<u8>` from gRPC json. gRPC serializes binary fields
+     * as base64 strings, but other code paths may pass through Uint8Array, plain arrays of
+     * bytes, or { vec: [...] } shapes — handle all of them.
+     */
+    static _decodeOptionVectorU8(value) {
+        if (value == null) return null;
+        if (value instanceof Uint8Array) return value;
+        if (typeof value === 'string') {
+            if (!value.length) return null;
+            const bin = (typeof Buffer !== 'undefined')
+                ? Buffer.from(value, 'base64')
+                : Uint8Array.from(atob(value), c => c.charCodeAt(0));
+            return new Uint8Array(bin.buffer, bin.byteOffset ?? 0, bin.byteLength ?? bin.length);
+        }
+        if (Array.isArray(value)) return value.length ? new Uint8Array(value) : null;
+        if (typeof value === 'object' && Array.isArray(value.vec)) {
+            return value.vec.length ? new Uint8Array(value.vec) : null;
+        }
+        return null;
+    }
+
+    static _decodeBcsU64(bcsBytes) {
+        const b = bcsBytes instanceof Uint8Array ? bcsBytes : new Uint8Array(bcsBytes);
+        const dv = new DataView(b.buffer, b.byteOffset, b.byteLength);
+        return Number(dv.getBigUint64(0, true));
+    }
 }