Smart Contracts Built for
the AI Era.

Cadence is a safe, resource-oriented programming language built for the Flow blockchain. Designed for digital ownership and optimized for AI-driven development.

$/plugin marketplace add onflow/flow-ai-tools

Install Flow's Claude Code skill suitedocs

Read the Docs GitHub

Architectural Pillars

EXPERIENCE

Atomic Multi-Step Transactions

Compose complex DeFi flows — claim, swap, restake — in a single transaction. Everything succeeds or everything reverts. No intermediary contracts needed.

SAFETY

User-Custodied Assets

User assets stay in user accounts, not in contract storage. Combined with a strong static type system and capability-based access control, Cadence eliminates entire classes of DeFi vulnerabilities.

COMPOSABILITY

Composable DeFi Primitives

Resources flow freely between contracts, enabling seamless integration of lending, swapping, and yield strategies. Build new DeFi functionality on top of any standard.

import "DeFiActions"
import "FlowToken"
import "IncrementFiStakingConnectors"
import "IncrementFiPoolLiquidityConnectors"
import "SwapConnectors"

// Schedule daily yield compounding with Flow Actions
transaction(stakingPoolId: UInt64, executionEffort: UInt64) {
    prepare(signer: auth(Storage, Capabilities) &Account) {

        // Compose DeFi actions atomically: Claim → Zap → Restake
        let operationID = DeFiActions.createUniqueIdentifier()
        
        // Source: Claim staking rewards
        let rewardsSource = IncrementFiStakingConnectors.PoolRewardsSource(
            userCertificate: signer.capabilities.storage
                .issue<&StakingPool>(/storage/userCertificate),
            pid: stakingPoolId,
            uniqueID: operationID
        )
        
        // Swapper: Convert single reward token → LP tokens
        let zapper = IncrementFiPoolLiquidityConnectors.Zapper(
            token0Type: Type<@FlowToken.Vault>(),
            token1Type: Type<@RewardToken.Vault>(),
            stableMode: false,
            uniqueID: operationID
        )
        
        // Compose: Wrap rewards source with zapper
        let lpSource = SwapConnectors.SwapSource(
            swapper: zapper,
            source: rewardsSource,
            uniqueID: operationID
        )
        
        // Sink: Restake LP tokens back into pool
        let poolSink = IncrementFiStakingConnectors.PoolSink(
            pid: stakingPoolId,
            staker: signer.address,
            uniqueID: operationID
        )
    }
}

The Paradigm Shift

LEDGER VS. RESOURCES

The Old Way (Ledger)

Centralized Accounting

Assets are just entries in a contract's private dictionary. To move value, you update two numbers. This "ledger" model is prone to reentrancy bugs.

mapping(address => uint) balances;
function transfer(address to, uint val) {
balances[msg.sender] -= val;
balances[to] += val;
}

The Cadence Way

Direct Ownership

Tokens live in the user's account as vault resources. Withdrawing creates a new resource the compiler tracks: it must be deposited or explicitly destroyed, it cannot be silently lost or duplicated.

let vault = signer.storage.borrow<
auth(FungibleToken.Withdraw) &FlowToken.Vault>
(from: /storage/flowTokenVault)!

let payment <- vault.withdraw(amount: 10.0)
receiver.deposit(from: <- payment)
// payment: must be deposited, cannot be duplicated

Watch The Intro

Smart Contracts Built for the AI Era.