Flow CLI

Retrieve the balance of any Fungible Token by providing its account address and the public path to its balance capability. You can also retrieve display metadata for a specific FT vault.

### Generic FT Balance (Any Token by Path)
```cadence
import FungibleToken from 0xf233dcee88fe0abe

access(all) fun main(address: Address, path: PublicPath): UFix64 {
    return getAccount(address).capabilities
        .borrow<&{FungibleToken.Balance}>(path)? .balance
        ?? panic("Could not borrow FungibleToken Balance capability for account \(address) at path \(path). Make sure the account has a Fungible Token Vault set up at this path.")
}

FT Metadata (Display Info)

import FungibleToken from 0xf233dcee88fe0abe
import FungibleTokenMetadataViews from 0xf233dcee88fe0abe

access(all) fun main(address: Address, vaultPath: PublicPath): FungibleTokenMetadataViews.FTDisplay? {
    let account = getAccount(address)
    let vaultRef = account.capabilities
        .borrow<&{FungibleToken.Vault}>(vaultPath)
        ?? panic("Could not borrow FungibleToken Vault capability for account \(address) at path \(vaultPath). Make sure the account has a Fungible Token Vault set up at this path.")
    return FungibleTokenMetadataViews.getFTDisplay(vaultRef)
}

Retrieve details about the current Flow epoch, including the counter, the current phase (Staking Auction, Epoch Setup, or Epoch Commit), metadata for a specific epoch, and timing configurations.

### Current Epoch Counter
```cadence
import FlowEpoch from 0x8624b52f9ddcd04a

access(all) fun main(): UInt64 {
    return FlowEpoch.currentEpochCounter
}

Current Epoch Phase

import FlowEpoch from 0x8624b52f9ddcd04a

// Returns: 0=StakingAuction, 1=EpochSetup, 2=EpochCommit
access(all) fun main(): UInt8 {
    return FlowEpoch.currentEpochPhase.rawValue
}

Epoch Metadata

import FlowEpoch from 0x8624b52f9ddcd04a

access(all) fun main(counter: UInt64): FlowEpoch.EpochMetadata {
    return FlowEpoch.getEpochMetadata(counter)!
}

Epoch Timing Config

import FlowEpoch from 0x8624b52f9ddcd04a

access(all) fun main(): FlowEpoch.EpochTimingConfig {
    return FlowEpoch.getEpochTimingConfig()
}

Use these Cadence scripts to retrieve the balance of a specific account for FLOW or to check the total supply of the FLOW token on mainnet.

Note: These scripts use mainnet addresses. For testnet, substitute addresses from the contract address tables in SKILL.md.

### FLOW Token Balance
```cadence
import FungibleToken from 0xf233dcee88fe0abe
import FlowToken from 0x1654653399040a61

access(all) fun main(address: Address): UFix64 {
    let account = getAccount(address)
    let vaultRef = account.capabilities
        .borrow<&{FungibleToken.Balance}>(/public/flowTokenBalance)
        ?? panic("Could not borrow FungibleToken Balance capability for account \(address) at path /public/flowTokenBalance. Make sure the account has a FlowToken Vault set up properly.")
    return vaultRef.balance
}

FLOW Total Supply

import FlowToken from 0x1654653399040a61

access(all) fun main(): UFix64 {
    return FlowToken.totalSupply
}

When standard CLI commands do not expose the required data (e.g., calling a contract view function or combining data from multiple contracts), use flow scripts execute.

Command Signature: flow scripts execute <script.cdc> [args...] [--args-json '<json_string>'] [--block-height N] [--block-id <id>] [--network <network>]

Argument Handling:

• Simple types (Address, UInt64, String, Bool): Pass as positional arguments.
• Complex types (UFix64, optionals, structs, arrays): Pass using the --args-json flag with JSON-Cadence encoding.
• Historical state: Use --block-height N or --block-id <id> to query state at a specific point in time.

Workflow Example:

1. Write your Cadence script to a temporary .cdc file.
2. Execute the script using flow scripts execute.
3. Clean up the temporary file.

flow scripts execute /tmp/query.cdc 0xe467b9dd11fa00df --network mainnet

# Using complex types
flow scripts execute /tmp/query.cdc --args-json '[{"type":"UFix64","value":"100.0"},{"type":"Address","value":"0xe467b9dd11fa00df"}]' --network mainnet

Retrieve protocol-level data such as the current node version and the latest random beacon source. You can also query NFT collections to get all token IDs and specific NFT metadata (display info).

### Current Node Version
```cadence
import NodeVersionBeacon from 0xe467b9dd11fa00df

access(all) fun main(): NodeVersionBeacon.Semver {
    return NodeVersionBeacon.getCurrentVersionBoundary().version
}

Latest Random Beacon Source

import RandomBeaconHistory from 0xe467b9dd11fa00df

access(all) fun main(): RandomBeaconHistory.RandomSourceHistoryEntry {
    return RandomBeaconHistory.getLatestSourceOfRandomness()
}

NFT Collection IDs

import NonFungibleToken from 0x1d7e57aa55817448

access(all) fun main(address: Address, collectionPublicPath: PublicPath): [UInt64] {
    let account = getAccount(address)
    let collectionRef = account.capabilities
        .borrow<&{NonFungibleToken.Collection}>(collectionPublicPath)
        ?? panic("Could not borrow NonFungibleToken Collection capability for account \(address) at path \(collectionPublicPath). Make sure the account has an NFT Collection set up at this path.")
    return collectionRef.getIDs()
}

NFT Metadata (Display)

import NonFungibleToken from 0x1d7e57aa55817448
import MetadataViews from 0x1d7e57aa55817448

access(all) fun main(address: Address, collectionPublicPath: PublicPath, id: UInt64): MetadataViews.Display? {
    let account = getAccount(address)
    let collectionRef = account.capabilities
        .borrow<&{NonFungibleToken.Collection}>(collectionPublicPath)
        ?? panic("Could not borrow NonFungibleToken Collection capability for account \(address) at path \(collectionPublicPath). Make sure the account has an NFT Collection set up at this path.")
    let nft = collectionRef.borrowNFT(id)!
    return MetadataViews.getDisplay(nft)
}

Access information regarding account storage capacity, available balances after storage reservation, account creation fees, and current transaction fee parameters.

### Account Storage Capacity
```cadence
import FlowStorageFees from 0xe467b9dd11fa00df

access(all) fun main(address: Address): UFix64 {
    return FlowStorageFees.calculateAccountCapacity(address)
}

Account Available Balance (After Storage Reservation)

import FlowStorageFees from 0xe467b9dd11fa00df

access(all) fun main(address: Address): UFix64 {
    return FlowStorageFees.defaultTokenAvailableBalance(address)
}

Account Creation Fee

import FlowServiceAccount from 0xe467b9dd11fa00df

access(all) fun main(): UFix64 {
    return FlowServiceAccount.accountCreationFee
}

Transaction Fee Parameters

import FlowFees from 0xf919ee77447b7497

access(all) fun main(): FlowFees.FeeParameters {
    return FlowFees.getFeeParameters()
}

For complex queries that are not covered by standard flow-cli commands, you can use Cadence scripts from official Flow repositories. To do this, clone the desired repository to a local directory (e.g., /tmp) and use the flow scripts execute command, pointing to the specific .cdc script file.

Recommended Repositories and Script Paths

# Example: use an existing script from flow-core-contracts
git clone --depth 1 https://github.com/onflow/flow-core-contracts.git /tmp/flow-core-contracts
flow scripts execute /tmp/flow-core-contracts/transactions/idTableStaking/scripts/get_node_info.cdc "abc123...def456" --network mainnet