chore: update SDK version to 0.3.0-3 and auto-fetch capability (#10)

* chore: update SDK version to 0.3.0-0, add .npmrc for authentication, and enhance AptosScriptComposer with auto-fetch capability

Author: WGB5445

examples/nextjs-project/src/app/components/ScriptComposer.tsx

@@ -27,7 +27,8 @@ export default function ScriptComposer() {
             function: '0x1::aptos_account::transfer',
             functionArguments: [CallArgument.newSigner(0), '0x1', 1],
             typeArguments: [],
-            moduleAbi: aptos_account_module.abi!,
+            moduleAbi: aptos_account_module.abi,
+            moduleBytecodes: [aptos_account_module.bytecode],
           });
           return composer
         },

examples/nodejs/index.ts

@@ -21,8 +21,9 @@ async function mainWithCache() {
         // Do not allow auto fetch
         options: {
           allowFetch: false,
-        }
-        // moduleAbi: aptos_account_module.abi,
+        },
+        moduleAbi: aptos_account_module.abi,
+        moduleBytecodes: [aptos_account_module.bytecode],
       });
       return composer
     },

examples/react-project/src/App.tsx

@@ -26,7 +26,8 @@ function App() {
             function: '0x1::aptos_account::transfer',
             functionArguments: [ CallArgument.newSigner(0) ,'0x1', 1],
             typeArguments: [],
-            moduleAbi: aptos_account_module.abi!,
+            moduleAbi: aptos_account_module.abi,
+            moduleBytecodes: [aptos_account_module.bytecode],
           });
           return composer
         },

packages/sdk/.npmrc

@@ -0,0 +1,3 @@
+//registry.npmjs.org/:_authToken=${NPM_TOKEN}
+registry=https://registry.npmjs.org/
+always-auth=true

packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aptos-labs/script-composer-sdk",
-  "version": "0.2.0",
+  "version": "0.3.0-3",
   "description": "Script Composer SDK",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -37,7 +37,6 @@
   "author": "",
   "license": "ISC",
   "peerDependencies": {
-    "@aptos-labs/script-composer-pack": "0.1.0",
     "@aptos-labs/ts-sdk": "^3.0.0 || ^4.0.0 || ^5.0.0"
   },
   "devDependencies": {
@@ -51,5 +50,8 @@
     "tsup": "8.5.0",
     "typescript": "5.8.3",
     "vitest": "3.2.4"
+  },
+  "dependencies": {
+    "@aptos-labs/script-composer-pack": "0.2.0"
   }
 }

packages/sdk/src/index.ts

@@ -39,9 +39,10 @@ export type InputBatchedFunctionData = {
   functionArguments: Array<
     EntryFunctionArgumentTypes | CallArgument | SimpleEntryFunctionArgumentTypes
   >;
-  moduleAbi: MoveModule;
+  moduleAbi?: MoveModule;
   moduleBytecodes?: string[];
   options?: {
+    /** @default true - Automatically fetch missing modules from the chain */
     allowFetch?: boolean;
   };
 };
@@ -88,33 +89,65 @@ export class AptosScriptComposer {
   // or the regular entry function arguments.
   //
   // The function would also return a list of `CallArgument` that can be passed on to future calls.
+  //
+  // Validation behavior:
+  // - If allowFetch is true (default): Validates that the function exists in the provided ABI (if any)
+  // - If allowFetch is false: Requires both moduleAbi and moduleBytecodes to be provided
+  // - Automatically fetches missing modules from the chain when allowFetch is enabled
   async addBatchedCalls(input: InputBatchedFunctionData): Promise<CallArgument[]> {
     const { moduleAddress, moduleName, functionName } = getFunctionParts(input.function);
     const module = input.moduleAbi;
     const moduleBytecode = input.moduleBytecodes;
+    const autoFetch = input.options?.allowFetch ?? true;
+
+    // Validation logic based on auto-fetch option
+    if (autoFetch) {
+      // Auto-fetch mode: Check if function exists in ABI
+      if (module) {
+        const functionAbi = module.exposed_functions.find((func) => func.name === functionName);
+        if (!functionAbi) {
+          throw new Error(
+            `Function '${functionName}' not found in provided ABI for module '${moduleAddress}::${moduleName}'`
+          );
+        }
+      }
+    } else {
+      // Manual mode: Check if both ABI and bytecode are provided
+      if (!module) {
+        throw new Error(
+          `Module ABI is required when auto-fetch is disabled for '${moduleAddress}::${moduleName}'`
+        );
+      }
+      if (!moduleBytecode || moduleBytecode.length === 0) {
+        throw new Error(
+          `Module bytecode is required when auto-fetch is disabled for '${moduleAddress}::${moduleName}'`
+        );
+      }
+    }
 
     moduleBytecode?.forEach((module) => {
       this.builder.store_module(Hex.fromHexInput(module).toUint8Array());
     });
 
-    if (!AptosScriptComposer.loadedModulesCache.has(`${moduleAddress}::${moduleName}`)) {
-      if (input.options?.allowFetch) {
-        // If the module is not loaded, we can fetch it.
-        const moduleBytecode = await getModuleInner({
-          aptosConfig: this.config,
-          accountAddress: moduleAddress,
-          moduleName: moduleName.toString(),
-        });
-        if (moduleBytecode) {
-          this.storeModule(moduleBytecode, `${moduleAddress}::${moduleName}`);
-        } else {
-          throw new Error(
-            `Module '${moduleAddress}::${moduleName}' could not be fetched. Please ensure it exists on the chain.`
-          );
-        }
+    const moduleId = `${moduleAddress}::${moduleName}`;
+    const isModuleLoaded = AptosScriptComposer.loadedModulesCache.has(moduleId);
+    const isModuleStored = this.storedModulesMap.has(moduleId);
+
+    // If the module is not loaded in the global cache (isModuleLoaded) or not stored in the local map (isModuleStored),
+    // and autoFetch is enabled, we need to fetch and store the module.
+    // This ensures that the module is available both globally and locally for execution.
+    if ((!isModuleLoaded || !isModuleStored) && autoFetch) {
+      // If the module is not loaded, we can fetch it.
+      const moduleBytecode = await getModuleInner({
+        aptosConfig: this.config,
+        accountAddress: moduleAddress,
+        moduleName: moduleName.toString(),
+      });
+      if (moduleBytecode) {
+        this.storeModule(moduleBytecode, moduleId);
       } else {
         throw new Error(
-          `Module '${moduleAddress}::${moduleName}' is not loaded in the cache. Please load it before using it in a batched call.`
+          `Module '${moduleAddress}::${moduleName}' could not be fetched. Please ensure it exists on the chain.`
         );
       }
     }
@@ -190,11 +223,11 @@ export class AptosScriptComposer {
   }
 
   /**
-   * Recursively collects all required module IDs from a given TypeTag, ensuring all dependent modules are present in the cache.
-   * If allowFetch is true, missing modules will be fetched from the chain and added to the cache.
+   * Recursively collects all required module IDs from a given TypeTag, ensuring all dependent modules are loaded and stored.
+   * If allowFetch is true, missing modules will be fetched from the chain and stored in both the global cache and local composer.
    *
    * @param typeTag - The TypeTag to analyze (can be struct, vector, etc.).
-   * @param options - Optional object. If options.allowFetch is true, missing modules will be fetched from the chain.
+   * @param options - Optional object. If options.allowFetch is true (default), missing modules will be fetched from the chain.
    * @returns Promise<Set<string>> - A set of all module IDs (address::moduleName) required by the typeTag and its nested type arguments.
    * @throws Error if a required module is missing and allowFetch is false, or if fetching fails.
    */
@@ -207,8 +240,9 @@ export class AptosScriptComposer {
       const structTag = typeTag as TypeTagStruct;
       const moduleId = `${structTag.value.address}::${structTag.value.moduleName.identifier.toString()}`;
       modules.add(moduleId);
+      const autoFetch = options?.allowFetch ?? true;
       if (!AptosScriptComposer.loadedModulesCache.has(moduleId)) {
-        if (options?.allowFetch) {
+        if (autoFetch) {
           // If the module is not loaded, we can fetch it.
           const module = await getModuleInner({
             aptosConfig: this.config,

packages/sdk/tests/composer.test.ts

@@ -70,7 +70,11 @@ test('test composer build txn', async () => {
     function: '0x1::coin::withdraw',
     functionArguments: [CallArgument.newSigner(0), 1],
     typeArguments: ['0x1::aptos_coin::AptosCoin'],
-    moduleAbi: coin_module.abi!,
+    moduleAbi: coin_module.abi,
+    moduleBytecodes: [coin_module.bytecode],
+    options: {
+      allowFetch: false,
+    },
   });
 
   // Passing the coin value to the 0x1::coin::coin_to_fungible_asset to convert a coin
@@ -80,15 +84,23 @@ test('test composer build txn', async () => {
     // coin[0] represents the first return value from the first call you added.
     functionArguments: [coin[0]],
     typeArguments: ['0x1::aptos_coin::AptosCoin'],
-    moduleAbi: coin_module.abi!,
+    moduleAbi: coin_module.abi,
+    moduleBytecodes: [coin_module.bytecode],
+    options: {
+      allowFetch: false,
+    },
   });
 
   // Deposit the fungibleAsset converted from second call.
   await builder.addBatchedCalls({
     function: '0x1::primary_fungible_store::deposit',
     functionArguments: ['0x1', fungibleAsset[0]],
     typeArguments: [],
-    moduleAbi: primary_fungible_store_module.abi!,
+    moduleAbi: primary_fungible_store_module.abi,
+    moduleBytecodes: [primary_fungible_store_module.bytecode],
+    options: {
+      allowFetch: false,
+    },
   });
 
   const tx = builder.build();
@@ -108,7 +120,11 @@ test('test composer build Payload', async () => {
     function: '0x1::coin::withdraw',
     functionArguments: [CallArgument.newSigner(0), 1],
     typeArguments: ['0x1::aptos_coin::AptosCoin'],
-    moduleAbi: coin_module.abi!,
+    moduleAbi: coin_module.abi,
+    moduleBytecodes: [coin_module.bytecode],
+    options: {
+      allowFetch: false,
+    },
   });
 
   // Passing the coin value to the 0x1::coin::coin_to_fungible_asset to convert a coin
@@ -119,14 +135,22 @@ test('test composer build Payload', async () => {
     functionArguments: [coin[0]],
     typeArguments: ['0x1::aptos_coin::AptosCoin'],
     moduleAbi: coin_module.abi!,
+    moduleBytecodes: [coin_module.bytecode],
+    options: {
+      allowFetch: false,
+    },
   });
 
   // Deposit the fungibleAsset converted from second call.
   await builder.addBatchedCalls({
     function: '0x1::primary_fungible_store::deposit',
     functionArguments: ['0x1', fungibleAsset[0]],
     typeArguments: [],
-    moduleAbi: primary_fungible_store_module.abi!,
+    moduleAbi: primary_fungible_store_module.abi,
+    moduleBytecodes: [primary_fungible_store_module.bytecode],
+    options: {
+      allowFetch: false,
+    },
   });
 
   const payload = builder.build_payload();
@@ -148,7 +172,11 @@ test('test composer build Txn', async () => {
         function: '0x1::coin::withdraw',
         functionArguments: [CallArgument.newSigner(0), 1],
         typeArguments: ['0x1::aptos_coin::AptosCoin'],
-        moduleAbi: coin_module.abi!,
+        moduleAbi: coin_module.abi,
+        moduleBytecodes: [coin_module.bytecode],
+        options: {
+          allowFetch: false,
+        },
       });
 
       // Passing the coin value to the 0x1::coin::coin_to_fungible_asset to convert a coin
@@ -158,15 +186,23 @@ test('test composer build Txn', async () => {
         // coin[0] represents the first return value from the first call you added.
         functionArguments: [coin[0]],
         typeArguments: ['0x1::aptos_coin::AptosCoin'],
-        moduleAbi: coin_module.abi!,
+        moduleAbi: coin_module.abi,
+        moduleBytecodes: [coin_module.bytecode],
+        options: {
+          allowFetch: false,
+        },
       });
 
       // Deposit the fungibleAsset converted from second call.
       await builder.addBatchedCalls({
         function: '0x1::primary_fungible_store::deposit',
         functionArguments: ['0x1', fungibleAsset[0]],
         typeArguments: [],
-        moduleAbi: primary_fungible_store_module.abi!,
+        moduleAbi: primary_fungible_store_module.abi,
+        moduleBytecodes: [primary_fungible_store_module.bytecode],
+        options: {
+          allowFetch: false,
+        },
       });
 
       return builder;
@@ -175,3 +211,74 @@ test('test composer build Txn', async () => {
 
   expect(txn).toBeDefined();
 });
+
+test('test composer with fetch enabled', async () => {
+  const builder = new AptosScriptComposer(new AptosConfig({ network: Network.TESTNET }));
+
+  // Test with allowFetch enabled (default behavior)
+  // This should automatically fetch the module from the chain without needing to store it first
+  const coin = await builder.addBatchedCalls({
+    function: '0x1::coin::withdraw',
+    functionArguments: [CallArgument.newSigner(0), 1000000], // 0.01 APT
+    typeArguments: ['0x1::aptos_coin::AptosCoin'],
+    // Note: Not providing moduleAbi or moduleBytecodes - should be fetched automatically
+    options: {
+      allowFetch: true, // Explicitly enable fetch (this is the default)
+    },
+  });
+
+  // Test chaining with another function that also uses fetch
+  const fungibleAsset = await builder.addBatchedCalls({
+    function: '0x1::coin::coin_to_fungible_asset',
+    functionArguments: [coin[0]],
+    typeArguments: ['0x1::aptos_coin::AptosCoin'],
+    // Again, not providing moduleAbi or moduleBytecodes
+    options: {
+      allowFetch: true,
+    },
+  });
+
+  // Final deposit call
+  await builder.addBatchedCalls({
+    function: '0x1::primary_fungible_store::deposit',
+    functionArguments: ['0x1', fungibleAsset[0]],
+    typeArguments: [],
+    // Testing default behavior (allowFetch should be true by default)
+    // options: { allowFetch: true } // This is the default, so we can omit it
+  });
+
+  const tx = builder.build();
+  expect(tx).toBeDefined();
+  expect(tx.length).toBeGreaterThan(0);
+});
+
+test('test composer fetch vs no-fetch behavior', async () => {
+  // Test that fetch is required when allowFetch is false and no ABI/bytecode provided
+  const builder = new AptosScriptComposer(new AptosConfig({ network: Network.TESTNET }));
+
+  // This should fail because allowFetch is false but no moduleAbi provided
+  await expect(
+    builder.addBatchedCalls({
+      function: '0x1::coin::withdraw',
+      functionArguments: [CallArgument.newSigner(0), 1000000],
+      typeArguments: ['0x1::aptos_coin::AptosCoin'],
+      options: {
+        allowFetch: false,
+      },
+    })
+  ).rejects.toThrow('Module ABI is required when auto-fetch is disabled');
+
+  // This should also fail because allowFetch is false but no moduleBytecodes provided
+  await expect(
+    builder.addBatchedCalls({
+      function: '0x1::coin::withdraw',
+      functionArguments: [CallArgument.newSigner(0), 1000000],
+      typeArguments: ['0x1::aptos_coin::AptosCoin'],
+      moduleAbi: coin_module.abi,
+      // Missing moduleBytecodes
+      options: {
+        allowFetch: false,
+      },
+    })
+  ).rejects.toThrow('Module bytecode is required when auto-fetch is disabled');
+});