@fizzyflow/endless-vector 0.0.3 → 0.0.4

package/EndlessVector.js

@@ -8,6 +8,7 @@ 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/transactions').TransactionResult} TransactionResult
  */
 
 /**
@@ -94,7 +95,7 @@ export default class EndlessVector {
      * @param {SuiClient} params.suiClient - Sui 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 {?Array<Uint8Array>} [params.items] - Optional array of Uint8Array items to initialize the vector with. If provided, uses empty_entry_and_push, otherwise uses empty_entry
+     * @param {?Uint8Array} [params.array] - Optional Uint8Array to initialize the vector with as the first item to get with .at(0)
      * @param {?Object} [params.gasCoin] - Optional gas coin object reference {objectId: string, digest: string, version: string} to use for transaction payment
      * @param {?Object} [params.options] - Optional transaction parameters
      * @param {?Number} [params.options.timeout] - Transaction confirmation timeout in ms, default 30000
@@ -103,7 +104,7 @@ export default class EndlessVector {
      * @throws {Error} If the transaction fails or no EndlessVector object is created
      */
     static async create(params) {
-        const { suiClient, packageId, signAndExecuteTransaction, items, gasCoin, options = {} } = params;
+        const { suiClient, packageId, signAndExecuteTransaction, array, gasCoin, options = {} } = params;
 
         let normalizedPackageId = packageId;
         if (normalizedPackageId == 'mainnet' || (!normalizedPackageId && suiClient?.network == 'mainnet')) {
@@ -129,10 +130,13 @@ export default class EndlessVector {
             tx.setGasPayment([gasCoin]);
         }
 
-        if (items && Array.isArray(items) && items.length) {
+        if (array && array.length) {
+            const vectorInput = await EndlessVector.getCreateTransactionAndReturnVectorInput({
+                packageId: normalizedPackageId,
+            }, array, tx);
             tx.moveCall({
-                target: `${normalizedPackageId}::endless_vector::empty_entry_and_push`,
-                arguments: [tx.pure(bcs.vector(bcs.vector(bcs.u8())).serialize(items))],
+                target: `${normalizedPackageId}::endless_vector::transfer_to_sender`,
+                arguments: [vectorInput],
             });
         } else {
             tx.moveCall({
@@ -180,33 +184,92 @@ export default class EndlessVector {
         });
     }
 
-    get isWritable() {
-        return !!(this._packageId && this._signAndExecuteTransaction);
-    }
-
     /**
-    * Creates a transaction to push new byte arrays to the EndlessVector.
-    * Note: this method only creates the transaction, it does not sign or execute it.
+     * Creates an empty EndlessVector and returns the vector input reference.
+     * Appends vector creation to existing transaction or makes new one.
+     * 
+     * Returns the vector input reference for use in subsequent move calls as argument or to be transferred.
+     *
+     * @param {Object} params - Configuration parameters
+     * @param {string} params.packageId - The package ID ('mainnet', 'testnet', or explicit package ID)
+     * @param {Uint8Array|null} [arr=null] - Optional Uint8Array to push back to the new vector as the first item
+     * @param {Transaction|null} [txToAppendTo=null] - Optional existing transaction to append the move calls to
+     * @returns {Promise<TransactionResult>} Vector input reference for use in subsequent move calls
+     * @throws {Error} Throws if packageId is not provided or invalid
+     *
+     * @example
+     * // Create an empty vector
+     * const vectorInput = await EndlessVector.getCreateTransactionAndReturnVectorInput({
+     *   packageId: 'mainnet'
+     * });
+     *
+     * @example
+     * // Create and populate a vector within an existing transaction
+     * const data = new Uint8Array([1, 2, 3, 4]);
+     * const tx = new Transaction();
+     * const vectorInput = await EndlessVector.getCreateTransactionAndReturnVectorInput({
+     *   packageId: contract.id
+     * }, data, tx);
+     */
+    static async getCreateTransactionAndReturnVectorInput(params, arr = null, txToAppendTo = null) {
+        const { packageId } = params;
+        let normalizedPackageId = packageId;
+        if (normalizedPackageId == 'mainnet') {
+            normalizedPackageId = ids['mainnet'].packageId;
+        } else if (normalizedPackageId == 'testnet') {
+            normalizedPackageId = ids['testnet'].packageId;
+        }
 
-    * @param {Uint8Array} arr - Array of byte arrays to push
-    * @returns {Transaction} The transaction object to be signed and executed
-    */
-    getPushTransaction(arr, txToAppendTo = null) {
-        if (!this._packageId) {
-            throw new Error('packageId is required to compose push transaction');
+        if (!normalizedPackageId) {
+            throw new Error('packageId is required');
         }
+        // Create transaction to call empty_entry
 
         let tx = txToAppendTo;
         if (!tx) {
             tx = new Transaction();
         }
 
+        const vectorInput = tx.moveCall({
+            target: `${normalizedPackageId}::endless_vector::empty`,
+            arguments: [],
+        });
+
+        if (arr && arr) {
+            EndlessVector.composePushTransaction(normalizedPackageId, vectorInput, arr, tx);
+        }
+
+        return vectorInput;
+    }
+
+    get isWritable() {
+        return !!(this._packageId && this._signAndExecuteTransaction);
+    }
+
+    /** 
+     * 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:
+     * tx.object(vector.id)
+     * or newly created one, accepting TransactionResult as vectorInput, see: getCreateTransactionAndReturnVectorInput
+     *
+     * For arrays smaller than 12KB, it uses a single push_back call.
+     * For arrays between 12KB and 120KB, it splits the data into 10 chunks and uses compose_and_push_back.
+     *
+     * @static
+     * @param {string} packageId - The package ID of the Move module containing the endless_vector functions
+     * @param {TransactionObjectArgument} vectorInput - The transaction object argument representing the 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)
+     */
+    static composePushTransaction(packageId, vectorInput, arr, tx) {
         const maxArgLength = 12 * 1024;
         if (arr.length < maxArgLength) {
                 tx.moveCall({
-                        target: `${this._packageId}::endless_vector::push_back`,
+                        target: `${packageId}::endless_vector::push_back`,
                         arguments: [
-                            tx.object(this.id),
+                            vectorInput,
                             tx.pure(bcs.vector(bcs.u8()).serialize(arr)),
                         ],
                     });
@@ -223,17 +286,41 @@ export default class EndlessVector {
                     chunks.push(new Uint8Array()); // empty chunk
                 }
             }
-            const args = [tx.object(this.id)];
+            const args = [vectorInput];
             for (let i = 0; i < N; i++) {
                 args.push(tx.pure(bcs.vector(bcs.u8()).serialize(chunks[i])));
             }
             tx.moveCall({
-                    target: `${this._packageId}::endless_vector::compose_and_push_back`,
+                    target: `${packageId}::endless_vector::compose_and_push_back`,
                     arguments: args,
                 });
         } else {
             throw new Error('Array too large, max '+(10*maxArgLength)+' bytes supported per single tx');
         }
+
+        return tx;
+    }
+
+
+    /**
+    * Creates a transaction to push new byte arrays to the EndlessVector.
+    * Note: this method only creates the transaction, it does not sign or execute it.
+
+    * @param {Uint8Array} arr - Uint8Array to push
+    * @returns {Transaction} The transaction object to be signed and executed
+    */
+    getPushTransaction(arr, txToAppendTo = null) {
+        if (!this._packageId) {
+            throw new Error('packageId is required to compose push transaction');
+        }
+
+        let tx = txToAppendTo;
+        if (!tx) {
+            tx = new Transaction();
+        }
+
+        EndlessVector.composePushTransaction(this._packageId, tx.object(this.id), arr, tx);
+
         return tx;
     }
 

package/README.md

@@ -32,10 +32,7 @@ const vector = await EndlessVector.create({
 const vectorWithData = await EndlessVector.create({
     suiClient: client,
     packageId: 'testnet',  // or 'mainnet' or '0xYOUR_PACKAGE_ID'
-    items: [
-        new Uint8Array([1, 2, 3]),
-        new Uint8Array([4, 5, 6])
-    ],
+    array: new Uint8Array([1, 2, 3]),  // [0] to append to EndlessVector
     signAndExecuteTransaction: async (tx) => {
         const result = await wallet.signAndExecuteTransaction({ transaction: tx });
         return result.digest;
@@ -57,7 +54,7 @@ console.log('Total items:', vector.length);
 console.log('Total size:', vector.binaryLength, 'bytes');
 
 // Read items
-const firstItem = await vector.at(0);
+const firstItem = await vector.at(0); // Uint8Array
 ```
 
 ## API Reference
@@ -72,7 +69,7 @@ Creates a new EndlessVector on the blockchain.
 - `suiClient` (SuiClient) - Sui client instance for blockchain interactions
 - `packageId` (string) - 'testnet', 'mainnet', or ID of the Move package containing the EndlessVector module
 - `signAndExecuteTransaction` (function) - Function to sign and execute transactions
-- `items` (Array<Uint8Array>, optional) - Initial items to push to the vector
+- `array` (Uint8Array, optional) - Optional first vector<u8> to push back to the new vector
 - `gasCoin` (Object, optional) - Gas coin object reference `{objectId: string, digest: string, version: string}` for transaction payment
 - `options` (Object, optional) - Additional options:
   - `timeout` (number) - Transaction confirmation timeout in ms (default: 30000)
@@ -85,7 +82,7 @@ Creates a new EndlessVector on the blockchain.
 const vector = await EndlessVector.create({
     suiClient: client,
     packageId: 'testnet',  // or 'mainnet' or '0xPACKAGE_ID'
-    items: [new Uint8Array([1, 2, 3])],
+    array: new Uint8Array([1, 2, 3]),
     gasCoin: {
         objectId: '0xGAS_COIN_ID',
         digest: 'DIGEST',
@@ -276,7 +273,7 @@ const vectors = await Promise.all(
         EndlessVector.create({
             suiClient: client,
             packageId: 'testnet',  // or 'mainnet' or '0xPACKAGE_ID'
-            items: items,
+            array: items,
             gasCoin: gasCoinRefs[i],
             signAndExecuteTransaction: async (tx) => {
                 const result = await wallet.signAndExecuteTransaction({ transaction: tx });

package/ids.js

@@ -1,11 +1,11 @@
 
 export default {
     'testnet': {
-        packageId: '0x5e35ef9e8ea315a4db40047b9133c028603168e7b41a27511e9f7eea38313685', // should be the same as in Move.lock
-        originalPackageId: '0x5e35ef9e8ea315a4db40047b9133c028603168e7b41a27511e9f7eea38313685',
+        packageId: '0x30bf8e91f40774ed08234f767360b4154562232903928b5f2f8fe5b2d51655bc', // should be the same as in Move.lock
+        originalPackageId: '0x30bf8e91f40774ed08234f767360b4154562232903928b5f2f8fe5b2d51655bc',
     },
     'mainnet': {
-        packageId: '0xa81971816c632022658736d464d35bd47a7d6b5ad60e0903697e4adda0aa1331', // should be the same as in Move.lock
-        originalPackageId: '0xa81971816c632022658736d464d35bd47a7d6b5ad60e0903697e4adda0aa1331',
+        packageId: '0x94cf19d164f014cfe73dda1121f27b54b69f0dbfa89d8b6ed48ae8a9144f5d65', // should be the same as in Move.lock
+        originalPackageId: '0x94cf19d164f014cfe73dda1121f27b54b69f0dbfa89d8b6ed48ae8a9144f5d65',
     },  
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fizzyflow/endless-vector",
-    "version": "0.0.3",
+    "version": "0.0.4",
     "description": "",
     "type": "module",
     "main": "./index.js",
@@ -24,7 +24,7 @@
     "author": "suidouble (https://github.com/suidouble)",
     "license": "Apache-2.0",
     "scripts": {
-        "test": "tap -j1 -t240 ./test/*.test.js"
+        "test": "tap -j1 -t320 ./test/*.test.js"
     },
     "peerDependencies": {
         "@mysten/sui": "^1.44.0"

package/test/base.test.js

@@ -71,6 +71,50 @@ test('attach a local package', async t => {
 });
 
 
+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({
+        suiClient: suiMaster.client,
+        id: createdVectorId,
+    });
+    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');
+});
 
 
 test('make a test EndlessVector and push single Uint8Array to it', async t => {
@@ -358,7 +402,7 @@ test('test parallel creation, push, and append of 6 vectors', async t => {
     // Prepare test data for each vector
     const testData = [];
     for (let i = 0; i < vectorCount; i++) {
-        testData.push([randomBytesOfLength(1024), new Uint8Array([0, 1, i])]);
+        testData.push(randomBytesOfLength(1024));
     }
 
     // Create N EndlessVectors in parallel using static create method
@@ -368,7 +412,7 @@ test('test parallel creation, push, and append of 6 vectors', async t => {
             EndlessVector.create({
                 suiClient: suiMaster.client,
                 packageId: contract.id,
-                items: testData[i] ? testData[i] : [],
+                array: testData[i] ? testData[i] : null,
                 gasCoin: gasCoinInputs[i],
                 signAndExecuteTransaction: async (tx) => {
                     console.log(`Creating vector ${i}...`);
@@ -407,24 +451,20 @@ test('test parallel creation, push, and append of 6 vectors', async t => {
     // Verify the data after concatenation
     await mainVector.initialize();
 
-    // Each vector has 2 items, so total should be vectorCount * 2
-    const expectedLength = vectorCount * 2;
+    const expectedLength = vectorCount;
     t.ok(mainVector.length === expectedLength, `mainVector should have ${expectedLength} items, got ${mainVector.length}`);
 
     console.log(`Verifying ${expectedLength} items in concatenated vector...`);
 
     // Verify each item matches the original testData
     for (let vectorIdx = 0; vectorIdx < vectorCount; vectorIdx++) {
-        for (let itemIdx = 0; itemIdx < testData[vectorIdx].length; itemIdx++) {
-            const globalIdx = vectorIdx * testData[vectorIdx].length + itemIdx;
-            const retrieved = await mainVector.at(globalIdx);
-            const expected = testData[vectorIdx][itemIdx];
-
-            t.ok(
-                equalUint8Arrays(retrieved, expected),
-                `Item ${globalIdx} (vector ${vectorIdx}, item ${itemIdx}) should match`
-            );
-        }
+        const expected = testData[vectorIdx];
+        const retrieved = await mainVector.at(vectorIdx);
+
+        t.ok(
+            equalUint8Arrays(retrieved, expected),
+            `Item ${vectorIdx} (vector ${vectorIdx}, item ${vectorIdx}) should match`
+        );
     }
 });