Search aptos examples

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

Building	Search For	Source	Key Files
NFT Collection	token_objects, mint_nft	aptos-core	token_objects/sources/token.move
Fungible Token	fungible_asset	aptos-core	fungible_asset/sources/fungible_asset.move
Marketplace	marketplace	aptos-core	marketplace/sources/marketplace.move
DAO	dao, voting	aptos-core	dao/sources/dao.move
Token Swap	swap, liquidity_pool	aptos-core	swap/sources/swap.move
Staking	staking	aptos-core	staking/sources/staking.move
Simple Contract	hello_blockchain, message_board	aptos-core	hello_blockchain/sources/hello.move
Object Patterns	object_playground	aptos-core	object_playground/sources/playground.move
Composable NFTs	composable-nfts	daily-move	snippets/composable-nfts/
FA Lockup/Escrow	fa-lockup-example	daily-move	snippets/fa-lockup-example/
Design Patterns	design-patterns	daily-move	snippets/design-patterns/
Move 2 Features	move-2	daily-move	snippets/move-2/
Data Structures	data-structures	daily-move	snippets/data-structures/
Storage Patterns	storage	daily-move	snippets/storage/
Loot Box Patterns	lootbox	daily-move	snippets/lootbox/

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.