Get Account Modules

Returns all Move modules' bytecode deployed by an account on the Aptos blockchain.

When to Use This Method

GET /accounts/{address}/modules is essential for:

• Smart Contract Discovery - Find all modules deployed by an account
• Code Verification - Retrieve module bytecode and ABI
• Dependency Analysis - Identify module dependencies
• Protocol Integration - Understand contract interfaces

Parameters

1. address - string (required)

   • The account address to query
   • Format: 64 hex characters with or without 0x prefix

2. ledger_version - string (optional)

   • Specific ledger version to query
   • If not provided, uses the latest version

3. start - string (optional)

   • Cursor for pagination (from X-Aptos-Cursor header)

4. limit - number (optional)

   • Maximum number of modules to return

Request Example

curl -X GET "https://api-aptos-mainnet.n.dwellir.com/v1/YOUR_API_KEY/accounts/0x1/modules" \
  -H "Accept: application/json"

Response Format

[
  {
    "bytecode": "0xa11ceb0b060000000b01000a020a12031c2504410405452d0772cf0108c1...",
    "abi": {
      "address": "0x1",
      "name": "aptos_coin",
      "friends": [],
      "exposed_functions": [
        {
          "name": "mint",
          "visibility": "public",
          "is_entry": true,
          "is_view": false,
          "generic_type_params": [],
          "params": ["&signer", "address", "u64"],
          "return": []
        }
      ],
      "structs": [
        {
          "name": "AptosCoin",
          "is_native": false,
          "abilities": ["key"],
          "generic_type_params": [],
          "fields": []
        }
      ]
    }
  }
]

Implementation Examples

TypeScript

import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";

const config = new AptosConfig({
  network: Network.MAINNET,
  fullnode: "https://api-aptos-mainnet.n.dwellir.com/v1/YOUR_API_KEY",
});

const aptos = new Aptos(config);

// Get all modules for an account
async function getAccountModules(address: string) {
  const modules = await aptos.getAccountModules({ 
    accountAddress: address 
  });
  
  return modules;
}

// Get specific module by name
async function getModule(address: string, moduleName: string) {
  const modules = await aptos.getAccountModules({ 
    accountAddress: address 
  });
  
  return modules.find(m => m.abi?.name === moduleName);
}

// List all functions in modules
async function getModuleFunctions(address: string) {
  const modules = await aptos.getAccountModules({ 
    accountAddress: address 
  });
  
  const functions = [];
  
  for (const module of modules) {
    if (module.abi?.exposed_functions) {
      for (const func of module.abi.exposed_functions) {
        functions.push({
          module: module.abi.name,
          function: func.name,
          isEntry: func.is_entry,
          isView: func.is_view,
          params: func.params,
          fullName: `${address}::${module.abi.name}::${func.name}`
        });
      }
    }
  }
  
  return functions;
}

// Find entry functions (can be called via transactions)
async function getEntryFunctions(address: string) {
  const modules = await aptos.getAccountModules({ 
    accountAddress: address 
  });
  
  const entryFunctions = [];
  
  for (const module of modules) {
    if (module.abi?.exposed_functions) {
      const entries = module.abi.exposed_functions.filter(f => f.is_entry);
      entryFunctions.push(...entries.map(f => ({
        module: module.abi.name,
        function: f.name,
        params: f.params,
        fullName: `${address}::${module.abi.name}::${f.name}`
      })));
    }
  }
  
  return entryFunctions;
}

Python

from aptos_sdk.client import RestClient
from aptos_sdk.account_address import AccountAddress
import json

client = RestClient("https://api-aptos-mainnet.n.dwellir.com/v1/YOUR_API_KEY")

def get_account_modules(address: str):
    """Get all modules deployed by an account"""
    account_addr = AccountAddress.from_str(address)
    modules = client.account_modules(account_addr)
    return modules

def get_module_by_name(address: str, module_name: str):
    """Get specific module by name"""
    modules = get_account_modules(address)
    
    for module in modules:
        if module.get("abi", {}).get("name") == module_name:
            return module
    
    return None

def list_module_functions(address: str):
    """List all functions across all modules"""
    modules = get_account_modules(address)
    functions = []
    
    for module in modules:
        abi = module.get("abi", {})
        module_name = abi.get("name", "unknown")
        
        for func in abi.get("exposed_functions", []):
            functions.append({
                "module": module_name,
                "function": func["name"],
                "is_entry": func["is_entry"],
                "is_view": func["is_view"],
                "params": func["params"],
                "full_name": f"{address}::{module_name}::{func['name']}"
            })
    
    return functions

def find_entry_functions(address: str):
    """Find all entry functions that can be called via transactions"""
    modules = get_account_modules(address)
    entry_functions = []
    
    for module in modules:
        abi = module.get("abi", {})
        module_name = abi.get("name", "unknown")
        
        for func in abi.get("exposed_functions", []):
            if func["is_entry"]:
                entry_functions.append({
                    "module": module_name,
                    "function": func["name"],
                    "params": func["params"],
                    "full_name": f"{address}::{module_name}::{func['name']}"
                })
    
    return entry_functions

def analyze_module_structs(address: str):
    """Analyze all structs defined in modules"""
    modules = get_account_modules(address)
    all_structs = []
    
    for module in modules:
        abi = module.get("abi", {})
        module_name = abi.get("name", "unknown")
        
        for struct in abi.get("structs", []):
            all_structs.append({
                "module": module_name,
                "struct": struct["name"],
                "abilities": struct["abilities"],
                "fields": struct.get("fields", []),
                "full_type": f"{address}::{module_name}::{struct['name']}"
            })
    
    return all_structs

Rust

use aptos_sdk::rest_client::Client;
use aptos_sdk::types::account_address::AccountAddress;
use std::str::FromStr;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(
        "https://api-aptos-mainnet.n.dwellir.com/v1/YOUR_API_KEY"
            .parse()?
    );
    
    let address = AccountAddress::from_str("0x1")?;
    
    // Get all modules
    let modules = client.get_account_modules(address, None).await?;
    
    println!("Found {} modules", modules.len());
    
    for module in modules {
        if let Some(abi) = &module.abi {
            println!("Module: {}", abi.name);
            
            // List exposed functions
            for func in &abi.exposed_functions {
                println!("  Function: {}", func.name);
                println!("    Entry: {}", func.is_entry);
                println!("    View: {}", func.is_view);
            }
        }
    }
    
    Ok(())
}

Common Use Cases

1. Protocol Discovery

Discover all contracts in a protocol:

async function discoverProtocol(protocolAddress: string) {
  const modules = await aptos.getAccountModules({ 
    accountAddress: protocolAddress 
  });
  
  const protocol = {
    address: protocolAddress,
    modules: modules.map(m => ({
      name: m.abi?.name,
      functions: m.abi?.exposed_functions?.length || 0,
      structs: m.abi?.structs?.length || 0,
      size: m.bytecode.length / 2 // Hex string to bytes
    })),
    totalModules: modules.length,
    totalFunctions: modules.reduce(
      (sum, m) => sum + (m.abi?.exposed_functions?.length || 0), 
      0
    ),
    entryPoints: [] as any[]
  };
  
  // Find all entry points
  for (const module of modules) {
    if (module.abi?.exposed_functions) {
      const entries = module.abi.exposed_functions
        .filter(f => f.is_entry)
        .map(f => `${protocolAddress}::${module.abi.name}::${f.name}`);
      protocol.entryPoints.push(...entries);
    }
  }
  
  return protocol;
}

2. ABI Generation

Generate TypeScript interfaces from module ABI:

function generateTypeScriptInterface(module: any): string {
  const abi = module.abi;
  if (!abi) return "";
  
  let output = `// Module: ${abi.address}::${abi.name}\n\n`;
  
  // Generate struct interfaces
  for (const struct of abi.structs || []) {
    output += `interface ${struct.name} {\n`;
    for (const field of struct.fields || []) {
      output += `  ${field.name}: ${moveTypeToTS(field.type)};\n`;
    }
    output += `}\n\n`;
  }
  
  // Generate function signatures
  output += `interface ${abi.name}Module {\n`;
  for (const func of abi.exposed_functions || []) {
    const params = func.params.map((p: string, i: number) => 
      `arg${i}: ${moveTypeToTS(p)}`
    ).join(", ");
    output += `  ${func.name}(${params}): Promise<any>;\n`;
  }
  output += `}\n`;
  
  return output;
}

function moveTypeToTS(moveType: string): string {
  const typeMap: Record<string, string> = {
    "u8": "number",
    "u16": "number",
    "u32": "number",
    "u64": "string",
    "u128": "string",
    "u256": "string",
    "bool": "boolean",
    "address": "string",
    "&signer": "Account",
    "vector<u8>": "Uint8Array"
  };
  
  return typeMap[moveType] || "any";
}

3. Module Dependency Analysis

Analyze module dependencies:

async function analyzeModuleDependencies(address: string) {
  const modules = await aptos.getAccountModules({ 
    accountAddress: address 
  });
  
  const dependencies = new Map<string, Set<string>>();
  
  for (const module of modules) {
    const moduleName = module.abi?.name || "unknown";
    const deps = new Set<string>();
    
    // Parse bytecode or ABI to find dependencies
    // This is simplified - actual implementation would parse Move bytecode
    const bytecodeStr = module.bytecode;
    
    // Look for common patterns in bytecode (simplified)
    const patterns = [
      /0x1::/g,  // Standard library
      /0x3::/g,  // Token standard
      /0x[a-f0-9]{64}::/g  // Other addresses
    ];
    
    for (const pattern of patterns) {
      const matches = bytecodeStr.match(pattern);
      if (matches) {
        matches.forEach(m => deps.add(m));
      }
    }
    
    dependencies.set(moduleName, deps);
  }
  
  return Object.fromEntries(dependencies);
}

4. Module Upgrade Detection

Monitor for module upgrades:

class ModuleMonitor {
  private moduleHashes = new Map<string, string>();
  
  async checkForUpgrades(address: string): Promise<any[]> {
    const modules = await aptos.getAccountModules({ 
      accountAddress: address 
    });
    
    const changes = [];
    
    for (const module of modules) {
      const moduleName = `${address}::${module.abi?.name}`;
      const currentHash = this.hashBytecode(module.bytecode);
      const previousHash = this.moduleHashes.get(moduleName);
      
      if (previousHash && previousHash !== currentHash) {
        changes.push({
          module: moduleName,
          type: "upgraded",
          previousHash,
          currentHash
        });
      } else if (!previousHash) {
        changes.push({
          module: moduleName,
          type: "new",
          hash: currentHash
        });
      }
      
      this.moduleHashes.set(moduleName, currentHash);
    }
    
    return changes;
  }
  
  private hashBytecode(bytecode: string): string {
    // Simple hash - in production use proper crypto hash
    return bytecode.substring(0, 16) + "..." + 
           bytecode.substring(bytecode.length - 16);
  }
}

Performance Optimization

Module Caching

class ModuleCache {
  private cache = new Map<string, {modules: any[], timestamp: number}>();
  private ttl = 60000; // 1 minute
  
  async getModules(address: string, forceRefresh = false) {
    const key = address;
    const cached = this.cache.get(key);
    
    if (!forceRefresh && cached && Date.now() - cached.timestamp < this.ttl) {
      return cached.modules;
    }
    
    const modules = await aptos.getAccountModules({ 
      accountAddress: address 
    });
    
    this.cache.set(key, {
      modules,
      timestamp: Date.now()
    });
    
    return modules;
  }
}

Error Handling

async function safeGetModules(address: string) {
  try {
    const modules = await aptos.getAccountModules({ 
      accountAddress: address 
    });
    
    return {
      success: true,
      data: modules,
      count: modules.length,
      totalSize: modules.reduce((sum, m) => sum + m.bytecode.length, 0)
    };
  } catch (error) {
    if (error.status === 404) {
      return {
        success: true,
        data: [],
        count: 0,
        message: "No modules deployed at this address"
      };
    }
    
    throw error;
  }
}

Need help? Contact our support team or check the Aptos documentation.