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

token_objects/
Modern object-based tokens (V2 pattern)
mint_nft/
NFT minting patterns
nft_dao/
NFT-gated governance
collection_manager/
Collection management
(daily-move) composable-nfts/
NFTs that contain other NFTs
(daily-move) modifying-nfts/
Mutable NFT metadata patterns
(daily-move) parallel-nfts/
Concurrent NFT minting
(daily-move) liquid-nfts/
Fractionalized/liquid NFTs

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

Fungible Assets

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

When to use: Creating tokens, currencies, reward points

DeFi & Trading

marketplace/
NFT marketplace patterns
swap/
Simple token swap
liquidity_pool/
AMM pool implementation
staking/
Staking mechanisms

When to use: Building DEXs, marketplaces, trading platforms

Governance & DAOs

dao/
DAO governance patterns
voting/
Voting mechanisms
multisig/
Multi-signature accounts

When to use: Building DAOs, governance systems, voting

Basic Patterns

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

When to use: Learning Move basics, simple contracts

Advanced Patterns

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

When to use: Complex architectures, security patterns

Gaming

(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:

Module Structure:

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

Object Creation:

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

Access Control:

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

Operations:

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

Testing:

What test patterns are used?
How is coverage achieved?

Step 4: Adapt Patterns to Your Use Case

Don't copy blindly - adapt:

Understand the pattern: Why is it structured this way?
Identify core concepts: What security checks are critical?
Adapt to your needs: Modify for your specific requirements
Maintain security: Keep all security checks intact
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&#x3C;FungibleStore&#x3C;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

Search: Find token_objects example

Review Structure:

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

Identify Key Patterns:

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

Adapt to Your Needs:

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

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.

search-aptos-examples

Safety Notice

Copy this and send it to your AI assistant to learn

Clone Aptos core

Navigate to examples

List all examples

View specific example

Source Transparency

Related Skills

generate-tests

write-contracts

deploy-contracts

analyze-gas-optimization