index

Releases and Installation

• Downloads
  • CryptoX Concordium Wallet
  • Concordium Wallet for Mobile
  • Concordium Wallet for Web
  • Concordium Desktop Wallet
  • Concordium LEDGER App
  • Concordium Legacy Wallet
  • Concordium Client 7.0.1-0
  • cargo-concordium
    • VSCode extension
  • Smart contract deploy and initialize tool
  • Concordium node distributions
    • Node performance monitoring
  • Genesis block
  • Voting tools
  • Auxiliary tools
    • Encrypt/decrypt tool v1.0.0
    • Company identity management tool v1.0.2
• Release notes
  • Wallets
    • CryptoX Concordium Wallet for iOS
    • CryptoX Concordium Wallet for Android
    • Concordium Wallet for Mobile for iOS
    • Concordium Wallet for Mobile for Android
    • Concordium Wallet for Web
    • Desktop Wallet
    • Concordium Legacy Wallet for iOS
    • Concordium Legacy Wallet for Android
    • Concordium LEDGER app
  • Nodes
    • Mainnet
    • Testnet
  • Tools
    • Concordium Client
    • cargo-concordium
    • VSCode extension
    • Smart contract deploy and initialize tool
    • CCDScan
  • Libraries
    • Smart contract Libraries

Concordium Basics

• Learn about Concordium
  • Identities
    • About identities
      • Attributes
      • Obtain an identity
    • About accounts
    • Disclosing an identity
      • Company identity creation
        • Using the Concordium Company ID tool
          • Request identity
          • Create account
            • Import created accounts into concordium-client
          • Identity recovery
  • Accounts
    • About accounts
      • Initial account
      • Account creation
      • Attributes
        • Benefits of revealing attributes
    • Disclosing an identity
    • Account concepts
      • Account balances
      • Account sequence number
      • Account aliases
    • Tools
      • The Desktop Wallet
      • The CryptoX Concordium Wallet
      • The Concordium Legacy Wallet
      • The Concordium Wallet for Mobile
      • The Concordium Wallet for Web
      • Command-line tool
  • Glossary of Concordium Terms
• Concordium wallets
  • Wallet FAQs
    • Deciding between the wallets
      • Why you need a wallet
      • Choosing the Right Wallet
      • Portability limits between wallets
      • Wallet Backups
      • What are the requirements for each wallet?
      • Comparison
      • Next steps
        • Transactions overview
          • How transactions work
          • Transaction fees
          • Tools
            • The CryptoX Concordium Wallet
            • The Desktop Wallet
            • The Concordium Wallet for Mobile
            • The Concordium Wallet for Web
            • The Concordium Legacy Wallet
            • Command-line tool
    • CryptoX Concordium Wallet FAQ
    • Concordium Wallet for Mobile FAQ
    • Concordium Wallet for Web FAQ
  • Set up a wallet
    • Set up the CryptoX Concordium Wallet
      • Get started
      • Basic navigation
        • More screen
        • Account navigation
    • Set up the Concordium Wallet for Web
      • Get started
      • Recovery phrase setup
      • Request your identity
      • Create an account
      • Basic navigation
        • Transactions overview
        • Find and share your account address
        • Change network
        • Light/dark mode toggle
      • Remove the Concordium Wallet for Web
    • Set up the Concordium Wallet for Mobile
      • Get started
      • Secret recovery phrase
      • Request your identity and account
        • Request identity
        • Request account
      • Basic navigation
        • Wallet settings
        • Account navigation
    • Set up the Concordium Legacy Wallet
      • Get started
      • Request your identity and initial account
    • Set up the Desktop Wallet
      • Before you start
  • Wallet activities
    • Create an identity
      • Change identity name
    • Create an account
      • Change account name
    • Backup and recovery
      • Make a backup of identities, accounts, and addresses
        • How to proceed
          • Upgrade
        • Final Notes
        • How to back up and import
      • Recover your Wallet
    • Update your passcode and biometric settings
    • Manage address book
    • Create a transaction report
    • Show my seed phrase
    • Import/export file
      • Import file
      • Export file
  • Account activities
    • Send CCD
    • Find and share your account address
    • Connect dApps to wallets
      • Proofs and revealing information
        • Example dApp
        • Concordium Wallet for Web
    • Tokens in the wallet
    • Unshield CCD on an account
    • Scheduled releases
      • Transfer CCD with a schedule in Desktop Wallet
        • Option 1: Create a regular interval schedule
        • Option 2: Create an explicit schedule
      • Inspect a release schedule
    • Export a private key
    • Export transaction logs
  • Desktop Wallet
    • Transfer CCD with a schedule in Desktop Wallet
      • Option 1: Create a regular interval schedule
      • Option 2: Create an explicit schedule
    • Apply a transaction log filter in the Desktop Wallet
    • Update the Desktop Wallet
      • Automatic updates
      • Manually updating
    • Desktop Wallet navigation and settings
      • More options
      • Desktop Wallet settings
        • Preferences
        • Node settings
        • Terms and conditions
    • Reset desktop wallet data
      • Delete the user data
    • Shared accounts with multiple credentials in Desktop Wallet
      • Credentials
      • Signature threshold
      • Share accounts
        • Step 1
        • Step 2
        • Step 3
        • Step 4
          • Create a credentials file
            • Create and export a file with credentials
          • Add credentials to an account
            • Add more credentials on an account
            • Prerequisites
            • Select an identity and an account
            • Change the signature threshold
            • Generate the transaction
              • Option 1: Generate the transaction without signing
              • Option 2: Generate and sign the transaction on the LEDGER device
            • Export the transaction proposal
            • Receive signatures from co-signers
            • Submit the transaction to the blockchain
          • Create a multi-signature CCD transfer in the Desktop Wallet
            • Prerequisites
            • Make a transfer proposal
            • Generate the transaction
              • Generate the transaction proposal without signing
              • Generate and sign the transaction proposal on the LEDGER device
            • Export a transaction proposal
            • Receive signatures from co-signers
            • Submit the transaction to the blockchain
          • Create a scheduled transfer in the Desktop Wallet
            • Send CCD with a schedule
            • Prerequisites
            • How a scheduled transfer works
            • Release schedule types
            • Make a transfer proposal
            • Add a release schedule
              • Option 1: Create a regular interval schedule
              • Option 2: Create an explicit schedule
            • Generate the transaction
              • Generate the transaction proposal without signing
              • Generate and sign the transaction proposal on the LEDGER device
            • Export a transaction proposal
            • Receive signatures from co-signers
            • Submit the transaction to the blockchain
          • Sign a transaction proposal
            • Import and sign a proposal
          • View transaction proposals
            • View a list of multi-signature proposals
• Staking with Concordium
  • Validation
    • Stake and lottery
    • Overview of the validation process
    • Time concepts
    • Validator keys
      • Validator account
    • Staking pool
    • When is a block final?
    • Tools to be a validator
      • Validation with Concordium Wallet for Web
      • Validation with Desktop Wallet
      • Validation with Concordium Legacy Wallet, Concordium Wallet for Mobile, and CryptoX Concordium Wallet
      • Validation with Concordium-client
    • Next steps
      • Validator management
        • Best practices for validation
          • Recommendations for staking pool owners
        • Research a staking pool
        • CCDScan
      • Add a validator
      • Change validator options
        • Update validator stake and restaking preference
        • Update pool settings
        • Update validator keys
        • Stop validation
      • Run a validator node on Windows
        • Prerequisites
        • Configure a validator node on Windows
        • View the node log
          • Troubleshooting
        • Other options for running a validator node
      • Run a validator node on macOS
        • Prerequisites
        • Configure a node as a validator
      • Run a validator node on Ubuntu
        • Prerequisites
        • Verify that a node is a validator node
      • Run a validator node on Docker
        • Prerequisites
        • Configure a node as a validator
      • Become a validator using the Concordium Client
        • Prerequisites
        • Start validation
          • Import the account
          • Create and register validator keys
        • Manage the validator
          • Check the status of the validator and its lottery power
          • Update the staked amount
          • Restake the earnings
          • Update validator keys
        • Configure a validator
        • Remove a validator
  • Delegation
    • Pools and Rewards
      • Bounding the size of pools
      • Pool reliability
      • Passive delegation
    • Time and cool-downs
    • Where delegation is available
    • Summary
      • Delegate to a staking pool or passive delegation
      • Update delegation to a staking pool or passive delegation
      • Remove delegation to a staking pool or passive delegation
  • Delegation and validation FAQ
    • For delegators
    • For validators
    • For validators, delegators and passive delegators

Develop on Concordium

• Developer resources
  • SDKs and APIs
  • Wallet SDK
    • Create an identity
      • Create an identity request
      • Send an identity request
      • Retrieve the identity after creation
    • Recover an identity
      • Generate an identity recovery request
      • Send an identity recovery request
    • Create an account
      • Create a credential deployment transaction
      • Sign a credential deployment transaction
      • Send a credential deployment transaction
    • Submit a transaction to a Concordium node
      • Construct and sign an account transaction
      • Send an account transaction to a Concordium node
    • Get the list of identity providers
      • Get list of identity providers and their metadata
  • dApp examples
  • Status Pages
    • Status pages
  • Auxiliary Tools
    • Decrypt encrypted output
    • Getting your private key from an account already imported to the concordium-client
  • gRPC V2 documentation
• Run a node on Concordium
  • System requirements to run a node
    • System requirements
    • Platforms
  • Node metrics
  • Synchronize a node with the network
    • Ubuntu nodes
      • Run a node on a server with Ubuntu on Mainnet
        • Prerequisites
        • Install the Debian package and run a node
        • Enable inbound connections
        • Synchronize a node with the network
        • Node collector configuration
        • Upgrade version
        • Run a validator node on Ubuntu
      • Run a node on a server with Ubuntu on Testnet
        • Prerequisites
        • Install the Debian package and run a node
        • Enable inbound connections
        • Synchronize a node with the network
        • Node collector configuration
        • Upgrade version
        • Run a validator node on Ubuntu
      • Troubleshoot a node on a server with Ubuntu
        • Database invariant violation error
        • Node crash or database corruption
    • MacOS nodes
      • Run and manage a node on macOS
        • Prerequisites
        • Install/upgrade and run a node
        • Verify that the node is running
          • Connect a node to the Desktop Wallet
        • Enable inbound connections
        • Change the node startup settings
        • Node collector configuration
        • Configure a node as a validator
        • View node logs
        • Synchronize a node with the network
        • Uninstall a macOS node
      • Troubleshoot a node on MacOS
        • Node crash or database corruption
        • Service cannot run after editing service (config) file
    • Windows nodes
      • Run and manage a node on Windows
        • Prerequisites
        • Install/upgrade and run a node
        • Verify that the node is running
        • Enable inbound connections
        • Connect a node to the Desktop Wallet
        • Change the node startup settings
        • Configure the Concordium Node Service
        • View the node log
        • Synchronize a node with the network
        • Node collector configuration
        • Validation on a Windows node
        • Uninstall a node running on Windows
      • Concordium Windows node runner service configuration
        • [node.nodeid]
          • name
          • enabled
          • bootstrap_nodes
          • config_dir
          • data_dir
          • baker_credentials
          • listen.port
          • listen.address
          • rpc.enabled
          • rpc.port
          • rpc.address
          • grpc2.port
          • grpc2.address
          • rpc.token
          • node.exe
          • node.env.*
          • node.args
          • collector.enabled
          • collector.url
          • collector.node_name
          • collector.log_file
          • collector.exe
          • collector.env.*
          • collector.args
          • log.level
          • log.path
          • log.roll.size
          • log.roll.count
          • log.roll.pattern
          • log.config
      • Troubleshoot a node running on Windows
        • Event viewer
        • Node crash or database corruption
    • Docker nodes
      • Run a node with Docker
        • Before you begin
        • Running/upgrading a node
        • Run a testnet node
          • Enable inbound connections
            • Retrieve node logs
          • Migration from the previous Docker distribution
        • Run a mainnet node
          • Enable inbound connections
            • Retrieve node logs
          • Migration from the previous Docker distribution
        • Run a validator node
        • Troubleshooting
          • Mounting host directories under SELinux
          • Letting the node container access the internet
      • Troubleshoot a node on a server with Docker
        • Database invariant violation error
        • Node crash or database corruption
    • AWS Marketplace nodes
      • Run a node on Amazon Web Services (AWS)
        • Before you begin
        • Running/upgrading a node
• Concordium Client
  • Run Concordium Client
  • Commands and help
  • Configuration
    • Location
    • Initialization
    • Display contents
      • Example:
    • Add accounts and keys
      • Add named account
      • Add key to an account
      • Update keys of an account
      • Remove keys of an account
      • Import accounts and keys from the Wallet apps
      • Show account aliases
  • Shell completion
    • Concordium Client transactions
      • Transaction commands
      • Commands for showing account information
        • Account sequence number
        • Account aliases
      • Commands for showing identity information
      • Commands for transferring CCD
        • Transfer CCD
          • Example: Transferring 25 CCD from one account to another
        • Unshield an amount
        • Transfer CCD with a schedule
      • Commands for delegation
        • Add delegation
        • Configure or change delegation
        • Stop delegation
      • Consensus commands
        • Show chain parameters
    • Querying a node
      • Account state
        • List accounts
          • Example
        • Inspect specific account
          • Example
      • Transaction status
        • Example
      • Block state
        • Inspect specific block
          • Example
      • Consensus state
        • Inspect consensus parameters
          • Example
        • Inspect consensus status
          • Example
        • ID layer
      • Exchange rates
      • Validator queries
        • Earliest time a validator may be expected to produce a block
    • Multi-sig
      • Create a multi-sig account
      • Configure the tool to use a multi-sig account
      • Create a multi-sig transaction
      • Add an additional signature to a multi-sig transaction
      • Send a multi-sig transaction on-chain
      • Additional resources
• Run a local chain
  • Prerequisites
    • Install the node distribution
    • Generate genesis data and account credentials
      • Build the tool
      • Run the tool
  • Run the local chain
    • Run the chain from a distribution binary
    • Run the chain as a Docker instance
  • Interact with the local chain
• Use Concordium's ID layer
  • Web3 ID
  • Entities
  • Issuance flow for verifiable credentials
  • Support for issuers and verifiers
    • Issuer
    • Verifier
      • Web3 ID in the Concordium Wallet for Web
        • Add verifiable credentials to the wallet
        • Backup verifiable credentials
        • Revoke verifiable credentials
        • Recover verifiable credentials
        • Use verifiable credentials
      • Web3 ID issuers
        • How to become an issuer
          • Concordium Issuer tool
      • Create proofs
        • General rules
        • Asking a user to reveal attributes
        • Range proofs
          • Structure a range proof
        • Membership proofs
          • Structure a membership proof
        • Tool to verify credentials
        • Concordium Proof Explorer
        • Example dApp
      • Concordia
        • Concordium’s bots
• Concordium low-code NFT framework
  • Low code NFT marketplace
  • Low-code NFT minting tool
    • Install the minting tool
    • Mint
• CCDScan
  • Delegation and staking pools
  • Use CCDScan
    • Home
      • CCDScan Blocks overview
        • Block details
      • CCDScan Transactions overview
        • Transaction details
      • CCDScan Accounts overview
        • Sender/Account details
      • CCDScan Staking overview
        • Staking pools view
        • Top delegators view
        • Passive delegation view
        • Validator details
      • CCDScan Nodes overview
        • Node details
• Concordium Standards

Indexers

• What are indexers
• SubQuery
  • Getting Started
  • Running and Hosting your Concordium SubQuery APIs

Smart Contracts

• Introduction
  • Auction smart contract example
  • Next steps
    • Additional reading
    • Smart contract development tools
      • Life cycle of a smart contract
      • Smart contract modules
        • On-chain language
          • Limitations
            • Floating point numbers
        • Deployment
        • Smart contracts on the chain
      • Smart contract instances
        • State of a smart contract instance
        • Instantiate a smart contract on-chain
        • Instance state
        • Interact with an instance
        • Log events
        • Limits
        • Invoke operations
        • Upgradeability
          • Failing to upgrade
          • Immutability
          • Migration
      • Smart contract schemas
        • Why use a contract schema
        • Should you embed or write to a file?
        • The schema format
        • Embed schemas on-chain
      • Develop smart contracts in Rust
        • Write a smart contract using concordium_std
          • Serializable state and parameters
          • Work with parameters
          • Work with queries
        • Build a smart contract module with cargo-concordium
        • Avoid creating black holes
• Quick start guide
• Ethereum developer onboarding
  • Concordium smart contracts
  • Events
  • Standards
  • Deploying and initializing smart contracts
  • Concordium tools
  • Miscellaneous
• Solana developer onboarding
  • Accounts
  • Smart contracts and programs
  • Example
    • Solana
    • Concordium
      • FAQ
        • Concordium smart contracts
        • Events
        • Standards
        • Deploying and initializing smart contracts
        • Concordium tools
        • Miscellaneous
• Contract development guides
  • Install tools for development
    • Rust and Cargo
    • cargo-concordium
      • VSCode extension
      • Typescript smart contract client generator
    • Concordium software
  • Set up a smart contract project
  • Compile a Rust smart contract module
    • Preparation
    • Compiling to Wasm
      • Non-verifiable builds
  • Return custom errors
    • Defining and deriving
    • Using custom errors
    • Standard error codes
  • Build a contract schema
    • Preparation
    • Setup the contract for a schema
      • Including schemas for init
      • Including schemas for receive
    • Building the schema
      • Embedding the schema
      • Outputting a schema file
      • Converting a binary schema to JSON
      • Converting a binary schema to base64
  • Build using no_std
    • Preparation
    • Setting up the module for no_std
    • Building the module
  • Fallback entrypoints
    • Preparation
    • What are fallback entrypoints
    • Using fallback entrypoints
  • Make a contract upgradeable
    • Owner can upgrade
  • Work with the JSON parameters
    • transfer() and TransferParams
    • updateOperator() and UpdateOperatorParams
    • balanceOf() and ContractBalanceOfQueryParams
    • operatorOf() and OperatorOfQueryParams
    • tokenMetadata() and ContractTokenMetadataQueryParams
  • Migrate contracts for concordium-std 8.1
    • Migrating init methods
    • Migrating receive methods
    • Migrating advanced state types
    • Reference material for migrating types and tests
  • Using the factory pattern on Concordium
    • Alternatives to the factory pattern
      • Construct the product directly
      • Register the instance with a contract registry
      • Use a monolithic contract
    • Implementing the factory pattern
      • The factory contract
        • The produce endpoint
      • The product contract
        • The initialize endpoint
    • Security considerations
• Test contracts
  • Creating a chain
  • Creating accounts
  • Deploy modules
  • Initialize contracts
  • Update contract entrypoints
  • Invoke contract entrypoints
  • Data for assertions
    • Return values
    • Balances
    • Contract trace elements
    • Transfers to accounts
• On-chain guides
  • Deploy a smart contract module
    • Preparation
    • Deployment
    • Naming a module
  • Initialize a smart contract instance
    • Preparation
    • Initialization
      • Passing parameters in JSON format
      • Passing parameters in binary format
    • Naming a contract instance
  • Interact with a smart contract instance
    • Preparation
    • Interaction
      • Passing parameters in JSON format
      • Passing parameters in binary format
  • Inspect a smart contract instance
    • Preparation
    • Inspection
  • Invoke a smart contract instance
    • Preparation
    • Invocation
      • Passing parameters in JSON format
      • Passing parameters in binary format
• Best practices
  • Development best practices
    • Mindset
    • Specification
    • Concordium Rust Smart Contracts
      • Recommended structure
      • Denial-of-service
        • External call failure
        • Operations with unknown bound
      • External Calls
        • General recommendations
        • Reentrancy
      • Code documentation
      • Automated testing
      • Checklist
  • Cost reduction best practices
    • Use a custom allocator
    • Use State-* types for maps, sets, and boxes
• References
  • Cryptographic primitives
    • References
  • Contract host functions
    • Logging events
      • log_event()
    • Function parameter
      • get_parameter_size()
      • get_parameter_section()
    • Smart contract instance state
      • state_create_entry()
      • state_lookup_entry()
      • state_delete_entry()
      • state_delete_prefix()
      • state_iterate_prefix()
      • state_iterator_next()
      • state_iterator_delete()
      • state_iterator_key_size()
      • state_iterator_key_read()
      • state_entry_size()
      • state_entry_read()
      • state_entry_write()
      • state_entry_resize()
    • Cryptographic primitives
      • verify_ed25519_signature()
      • verify_ecdsa_secp256k1_signature()
      • hash_sha2_256()
      • hash_sha3_256()
      • hash_keccak_256()
    • Chain data
      • get_slot_time()
    • Identity data
      • get_policy_section()
    • Only in init function
      • get_init_origin()
    • Only in receive function
      • invoke()
      • upgrade()
      • get_receive_invoker()
      • get_receive_sender()
      • get_receive_self_address()
      • get_receive_owner()
      • get_receive_self_balance()
      • get_receive_entrypoint_size()
      • get_receive_entrypoint()
  • Local settings
    • Local Names
      • Account Names
      • Module Names
      • Contract Instance Names
  • References on-chain
    • Modules
    • Contract instances
  • Schema JSON representation
    • JSON for schema type
      • Unit
      • U8, U16, U32, U64, I8, I16, I32, I64
      • U128, I128
      • Amount
      • AccountAddress
      • ContractAddress
      • Timestamp
      • Duration
      • Pair
      • List
      • Set
      • Map
      • Array
      • Struct
      • Enum
      • String
      • ContractName
      • ReceiveName
      • ULeb128
      • ILeb128
      • ByteList
      • ByteArray
    • JSON for schema type fields
      • Named
      • Unnamed
      • Empty
  • Simulation contexts
    • Init context
      • metadata
      • initOrigin
      • senderPolicies
    • Receive context
      • metadata
      • invoker
      • sender
      • senderPolicies
      • owner
      • selfAddress
      • selfBalance
    • Chain meta data
      • slotTime
    • Policy
      • identityProvider
      • createdAt
      • validTo
  • Rust contract examples (repo)
  • concordium-std
• V0 smart contracts
  • Introduction and general guides
    • What are smart contracts for?
      • Auction smart contract example
    • What are smart contracts not for?
    • Life cycle of a smart contract
      • Smart contract modules
        • On-chain language
          • Limitations
            • Floating point numbers
        • Deployment
        • Smart contract on the chain
      • Smart contract instances
        • State of a smart contract instance
        • Instantiating a smart contract on-chain
        • Instance state
        • Interacting with an instance
        • Logging events
        • Action descriptions
          • Processing multiple action descriptions
          • Handling errors
      • Smart contract schemas
        • Why use a contract schema
        • Should you embed or write to a file?
        • The schema format
        • Embedding schemas on-chain
      • Developing smart contracts in Rust
        • Writing a smart contract using concordium_std
          • Serializable state and parameters
          • Working with parameters
        • Building a smart contract module with cargo-concordium
        • Best practices
          • Avoid creating black holes
  • Tutorials
    • Writing the piggy bank smart contract
      • Preparation
      • Bring in the standard library
      • Piggy bank contract
      • Specifying the state
      • Set up a piggy bank
        • The #[init] macro
      • Define interaction with piggy banks
        • The #[receive(...)] macro
        • Inserting CCD
        • Smashing a piggy bank
    • Testing the piggy bank smart contract
      • Preparation
      • Add a test module
      • Testing instantiation of a piggy bank
      • Test inserting CCD into a piggy bank
      • Test smashing a piggy bank
      • Testing cause of rejection
      • Compiling and running tests in Wasm
      • Simulating the piggy bank
  • Contract development guides
    • Install tools for development
      • Rust and Cargo
      • Cargo Concordium
        • VSCode extension
      • Concordium software
    • Setting up a smart contract project
      • Adding the smart contract standard library
    • Compile a Rust smart contract module
      • Preparation
      • Compiling to Wasm
      • Removing host information from build
        • Caveats
    • Unit test a contract in Rust
      • Writing unit tests
      • Running tests in Wasm
    • Return custom errors
      • Defining and deriving
      • Using custom errors
      • Standard error codes
    • Locally simulate contract functions
      • Preparation
      • Simulating instantiation
      • Simulating updates
    • Build a contract schema
      • Preparation
      • Setup the contract for a schema
        • Including contract state
        • Including function parameters
      • Building the schema
        • Embedding the schema
        • Outputting a schema file
    • Build using no_std
      • Preparation
      • Setting up the module for no_std
      • Building the module
  • On-chain guides
    • Deploy a smart contract module
      • Preparation
      • Deployment
      • Naming a module
    • Initialize a smart contract instance
      • Preparation
      • Initialization
        • Passing parameters in JSON format
        • Passing parameters in binary format
      • Naming a contract instance
    • Interact with a smart contract instance
      • Preparation
      • Interaction
        • Passing parameters in JSON format
        • Passing parameters in binary format
    • Inspect a smart contract instance
      • Preparation
      • Inspection
  • References
    • Schema JSON representation
      • JSON for schema type
        • Unit
        • U8, U16, U32, U64, I8, I16, I32, I64
        • U128, I128
        • Amount
        • AccountAddress
        • ContractAddress
        • Timestamp
        • Duration
        • Pair
        • List
        • Set
        • Map
        • Array
        • Struct
        • Enum
        • String
        • ContractName
        • ReceiveName
      • JSON for schema type fields
        • Named
        • Unnamed
        • Empty
    • Simulation contexts
      • Init context
        • metadata
        • initOrigin
        • senderPolicies
      • Receive context
        • metadata
        • invoker
        • sender
        • senderPolicies
        • owner
        • selfAddress
        • selfBalance
      • Chain meta data
        • slotTime
      • Policy
        • identityProvider
        • createdAt
        • validTo
    • Contract host functions
      • Logging events
      • Function parameter
      • Smart contract instance state
      • Chain data
      • Identity data
      • Only in init function
      • Only in receive function
        • Action description
    • References on-chain
      • Modules
      • Contract instances
    • Local settings
      • Local Names
        • Account Names
        • Module Names
        • Contract Instance Names
    • Rust contract examples (repo)
    • concordium-std

Tutorials

• Smart contract tutorials
  • Setup the development environment
    • Download and run Concordium Client
    • Concordium node on Testnet
    • Setup a wallet
      • Import the key
  • Counter
    • Update counter
      • View function
    • Build, deploy, and initialize the contract
    • Interact with the contract
      • View function
      • Update function
  • PiggyBank
    • Writing the piggy bank smart contract
      • Preparation
      • Bring in the standard library
      • Piggy bank contract
      • Specifying the state
      • Set up a piggy bank
        • The #[init] macro
      • Define interaction with piggy banks
        • The #[receive(...)] macro
        • Inserting CCD
        • Smashing a piggy bank
        • Viewing the state
    • Testing the piggy bank smart contract
      • Preparation
      • Adding the testing library
      • Add a test module
      • Testing instantiation of a piggy bank
      • Test inserting CCD into a piggy bank
      • Test smashing a piggy bank
      • Testing cause of rejection
    • Deploying the piggy bank smart contract
      • Preparation
      • Building a Wasm module
      • Deploying a module
      • Initializing a module
      • Updating the piggy bank smart contract
      • Viewing the piggy bank state
      • Smashing the piggy bank smart contract
        • Concordium-std crate errors
        • Smart contract errors
    • Setting up a frontend
  • wCCD
    • Understanding the wCCD token protocol
      • Contract addresses
    • Interacting with the wCCD token protocol
      • Query (non-state-mutative) functions
        • Getting the CCD balance of an address
        • The balanceOf function
        • The operatorOf function
        • The tokenMetadata function
        • The supports function
      • State-mutative functions
        • The wrap function
        • The unwrap function
        • The transfer function
        • The updateOperator function
    • Setting up the frontend
      • Concordium Wallet for Web
      • Running the web frontend
      • Conclusion
  • The Voting dApp
    • Writing a voting smart contract
      • Preparation
      • Basic setup
        • Initializing
        • Performance considerations
    • Setting up the frontend
      • Concordium Wallet for Web
      • Installation
      • Running the web frontend
  • Mint an NFT
    • Upload the NFT
      • Using InterPlanetary File System (IPFS)
      • Assign NFT Metadata
    • Initialize, build, and deploy the smart contract
      • Initialize Cis2-NFT contract template
      • Build your smart contract
      • Deploy your smart contract
      • Initializing the smart contract
    • Mint and transfer the NFT
      • View function
      • Transfer function
  • Mint a semi-fungible token
    • What are Semi-Fungible Tokens
      • Setup the development environment
      • Smart contract modifications
        • Build the contract module
        • Deploy the smart contract
        • Initialize the smart contract
      • Mint and transfer semi-fungible token
        • View contract state and metadata
        • Transfer the token
  • Mint fungible tokens
    • Concordium Interoperability Standard (CIS-2)
      • Smart contract implementation for fungible tokens
        • Minting
        • Mint function
          • Contract mint function
          • State mint function
          • Contract burn function
        • Build, deploy, and initialize
          • Build the smart contract
          • Deploy the smart contract
          • Initialize the smart contract
      • Mint, transfer, and burn fungible tokens
        • Transfer tokens
        • Burn tokens
  • NFT marketplace smart contract tutorial
    • Build and deploy the smart contract
      • Initialize the marketplace smart contract
      • UpdateOperator and add token
      • Transfer the token
  • eSealing
    • What is file sealing? What is timestamping?
      • Exploring the eSealing dapp
        • Register a file
        • View timestamp and witness
        • Use Concordium Client
        • What is the cost of using your account to seal a file?
  • Sponsored Transactions
    • What are sponsored transactions?
    • What are the use cases of sponsored transactions?
    • What is the difference between a normal transaction vs. a sponsored transaction?
      • Exploring the sponsored Transactions Smart Contract
        • permit function
        • supportsPermit function
        • Nonces registry
        • Testing the signature verification
      • Exploring the sponsored Transactions dApp
        • Schemas
        • Explore your public key
        • Submit a sponsored updateOperator transaction
        • Submit a sponsored transfer transaction
  • Smart Contract Upgrade
    • Native upgradability
      • The migration function
      • The upgrade function
      • Executing an upgrade
• Using ID tutorial
  • Writing the verifying backend
    • Serve statement and names
    • Serve challenge
    • Verify Proof
    • Serve Images
  • Interacting with a wallet
  • Setting up the frontend

Governance Committee Voting

• Concordium Governance Committee Elections
  • Before the election
  • During the election
  • After the election
  • Components for voting
• Election coordinator tool
  • Build and run
  • Commands
    • Get the list of initial weights
    • Create a new election instance
    • Get the final weights
    • Tally the votes and register the encrypted tally in the contract
    • Decrypt the final result
• How to vote
  • For CryptoX Concordium Wallet, Concordium Wallet for Web, Concordium Wallet for Mobile and CryptoX Concordium Wallet wallet holders
    • Voting from multiple accounts
  • For Desktop wallet, Concordium Legacy Wallet and Concordium Client wallet holders
  • How to see delegations
• Guardians
  • Pre-setup
  • Setup
    • Generate guardian keys
    • Generate and register encrypted shares
    • Generate secret key share
  • After the election
    • Generate your decrypted share
    • Register the decrypted share in the contract
  • Uninstall the app
    • Windows
    • MacOS
    • Linux
• Verify election result
  • Commands
    • Verify the list of initial weights
    • Get the final weights
    • Verify the encrypted tally registered in the contract
    • Verify the election result