Search Aptos Examples Skill

Overview

This skill helps you find relevant examples in official Aptos repositories before writing new contracts. Always search examples first to follow established patterns.

Repositories:

• aptos-labs/aptos-core/aptos-move/move-examples/ — 53+ official Move examples demonstrating best practices
• aptos-labs/daily-move/snippets/ — 17 curated educational examples covering design patterns, Move 2 features, composable NFTs, and more

Core Workflow

Step 1: Identify What You’re Building

Categorize your contract:

• NFTs/Tokens: NFT collections, digital assets, collectibles
• Fungible Assets: Coins, tokens, currencies
• DeFi: DEXs, AMMs, lending, staking
• Governance: DAOs, voting, proposals
• Marketplace: Trading, escrow, auctions
• Gaming: Items, characters, game logic
• Infrastructure: Registries, configs, utilities

Step 2: Search Relevant Examples

Priority Examples by Category:

NFTs & Token Objects

1. token_objects/ – Modern object-based tokens (V2 pattern)
2. mint_nft/ – NFT minting patterns
3. nft_dao/ – NFT-gated governance
4. collection_manager/ – Collection management
5. (daily-move) composable-nfts/ – NFTs that contain other NFTs
6. (daily-move) modifying-nfts/ – Mutable NFT metadata patterns
7. (daily-move) parallel-nfts/ – Concurrent NFT minting
8. (daily-move) liquid-nfts/ – Fractionalized/liquid NFTs

When to use: Building NFT collections, digital collectibles, tokenized assets

Fungible Assets

1. fungible_asset/ – Modern fungible token standard
2. coin/ – Basic coin implementation
3. managed_fungible_asset/ – Controlled fungible assets
4. (daily-move) fa-lockup-example/ – FA lockup and escrow patterns
5. (daily-move) fractional-token/ – Fractional token ownership
6. (daily-move) controlled-mint/ – Controlled minting with access control

When to use: Creating tokens, currencies, reward points

DeFi & Trading

1. marketplace/ – NFT marketplace patterns
2. swap/ – Simple token swap
3. liquidity_pool/ – AMM pool implementation
4. staking/ – Staking mechanisms

When to use: Building DEXs, marketplaces, trading platforms

Governance & DAOs

1. dao/ – DAO governance patterns
2. voting/ – Voting mechanisms
3. multisig/ – Multi-signature accounts

When to use: Building DAOs, governance systems, voting

Basic Patterns

1. hello_blockchain/ – Module structure basics
2. message_board/ – Simple state management
3. resource_account/ – Resource patterns (legacy – avoid for new code)
4. (daily-move) error-codes/ – Error code conventions and patterns
5. (daily-move) private-vs-public/ – Function visibility and access
6. (daily-move) objects/ – Object model fundamentals

When to use: Learning Move basics, simple contracts

Advanced Patterns

1. object_playground/ – Object model exploration
2. capability/ – Capability-based security
3. upgradeable/ – Upgradeable contracts
4. (daily-move) design-patterns/ – Autonomous objects and other design patterns
5. (daily-move) struct-capabilities/ – Struct-based capability patterns
6. (daily-move) move-2/ – Move 2 language features and idioms
7. (daily-move) storage/ – Storage layout and optimization patterns
8. (daily-move) data-structures/ – Heap data structure implementation

When to use: Complex architectures, security patterns

Gaming

1. (daily-move) lootbox/ – Randomized loot box mechanics

When to use: Building games, randomized rewards, loot systems

Step 3: Review Example Code

What to look for:

1. Module Structure:

   • How are imports organized?
   • What structs are defined?
   • How are error codes structured?

2. Object Creation:

   • How are objects created?
   • Which refs are generated?
   • How is ownership managed?

3. Access Control:

   • How is signer authority verified?
   • How is object ownership checked?
   • What roles/permissions exist?

4. Operations:

   • How are transfers handled?
   • How are updates secured?
   • What validations are performed?

5. Testing:

   • What test patterns are used?
   • How is coverage achieved?

Step 4: Adapt Patterns to Your Use Case

Don’t copy blindly – adapt:

1. Understand the pattern: Why is it structured this way?
2. Identify core concepts: What security checks are critical?
3. Adapt to your needs: Modify for your specific requirements
4. Maintain security: Keep all security checks intact
5. Test thoroughly: Ensure 100% coverage

Example Discovery Table

How to Access Examples

Option 1: GitHub Web Interface

https://github.com/aptos-labs/aptos-core/tree/main/aptos-move/move-examples

Browse online and read source files directly.

Option 2: Clone Repository (Recommended)

# Clone Aptos core
git clone https://github.com/aptos-labs/aptos-core.git

# Navigate to examples
cd aptos-core/aptos-move/move-examples

# List all examples
ls -la

# View specific example
cd token_objects
cat sources/token.move

Option 3: daily-move Repository

Browse online:

https://github.com/aptos-labs/daily-move/tree/main/snippets

Clone locally:

git clone https://github.com/aptos-labs/daily-move.git
cd daily-move/snippets
ls -la

Option 4: Search Aptos Documentation

https://aptos.dev/build/smart-contracts

Many examples are documented with explanations.

Common Patterns from Examples

Pattern 1: Object Creation (from token_objects)

// From: token_objects/sources/token.move
public entry fun create_token(
    creator: &signer,
    collection_name: String,
    description: String,
    name: String,
    uri: String,
) {
    let constructor_ref = token::create_named_token(
        creator,
        collection_name,
        description,
        name,
        option::none(),
        uri,
    );
    // ... additional setup
}

Takeaway: Use named tokens for collections, create_object for unique items.

Pattern 2: Access Control (from dao)

// From: dao/sources/dao.move
public entry fun execute_proposal(
    proposer: &signer,
    proposal_id: u64
) acquires DAO, Proposal {
    let dao = borrow_global_mut<DAO>(@dao_addr);
    let proposal = vector::borrow_mut(&mut dao.proposals, proposal_id);

    // Verify proposal passed
    assert!(proposal.votes_for > proposal.votes_against, E_PROPOSAL_NOT_PASSED);

    // Execute actions
    // ...
}

Takeaway: Verify state conditions before executing critical operations.

Pattern 3: Transfer Control (from fungible_asset)

// From: fungible_asset/sources/fungible_asset.move
public fun transfer<T: key>(
    from: &signer,
    to: address,
    amount: u64
) acquires FungibleStore {
    // Verify sender has sufficient balance
    let from_store = borrow_global_mut<FungibleStore<T>>(signer::address_of(from));
    assert!(from_store.balance >= amount, E_INSUFFICIENT_BALANCE);

    // Deduct from sender
    from_store.balance = from_store.balance - amount;

    // Add to recipient
    let to_store = borrow_global_mut<FungibleStore<T>>(to);
    to_store.balance = to_store.balance + amount;
}

Takeaway: Check-effects-interactions pattern (verify, deduct, add).

ALWAYS Rules

• ✅ ALWAYS search examples before writing new contracts
• ✅ ALWAYS check both aptos-core (canonical) and daily-move (educational) repositories
• ✅ ALWAYS understand patterns before copying
• ✅ ALWAYS adapt patterns to your use case
• ✅ ALWAYS maintain security checks from examples
• ✅ ALWAYS reference which example you adapted from
• ✅ ALWAYS test adapted code thoroughly

NEVER Rules

• ❌ NEVER copy code without understanding it
• ❌ NEVER skip security checks from examples
• ❌ NEVER use deprecated patterns (resource accounts, address-based)
• ❌ NEVER assume examples are always up-to-date (verify against docs)
• ❌ NEVER mix V1 and V2 patterns
• ❌ NEVER include real private keys or credentials when adapting examples — use "0x..." placeholders

Search Checklist

Before writing contract code:

• Identified category (NFT, DeFi, DAO, etc.)
• Found 2-3 relevant examples in aptos-core
• Checked daily-move snippets for educational examples
• Reviewed module structure
• Identified security patterns
• Understood object creation patterns
• Noted access control mechanisms
• Checked test patterns
• Ready to adapt to my use case

Example Adaptation Workflow

Step-by-Step: Building NFT Collection

1. Search: Find token_objects example

2. Review Structure:

   token_objects/
   ├── sources/
   │   ├── collection.move  # Collection management
   │   ├── token.move       # Token operations
   │   └── property_map.move # Metadata handling
   └── tests/
       └── token_tests.move
   

3. Identify Key Patterns:

   • Collection creation with create_collection
   • Token minting with create_named_token
   • Metadata storage using PropertyMap
   • Transfer control with TransferRef

4. Adapt to Your Needs:

   • Keep object creation pattern
   • Keep security checks
   • Add your custom fields
   • Add your business logic
   • Write comprehensive tests

5. Reference in Code:

   // Adapted from: aptos-core/move-examples/token_objects
   module my_addr::custom_nft {
       // ... your implementation
   }
   

References

Official Examples:

• aptos-core: https://github.com/aptos-labs/aptos-core/tree/main/aptos-move/move-examples
• daily-move: https://github.com/aptos-labs/daily-move/tree/main/snippets
• Documentation: https://aptos.dev/build/smart-contracts

Related Skills:

• write-contracts – Apply patterns after searching
• security-audit – Verify security of adapted code
• generate-tests – Test adapted patterns

Remember: Search examples first. Understand patterns. Adapt securely. Test thoroughly.