Cấu trúc cơ bản của ink! smart contract

    #[ink::contract]
    mod <tên module> {
        ...
    }

    #[ink(storage)]
    pub struct <tên contract> {
        // Các trường dữ liệu on-chain
    }

#[ink(storage)]
pub struct MyContract {
    // Store a bool
    my_bool: bool,
    // Store some number
    my_number: u32,
    // Store some String
    my_string: String,
    // Store some u32 in a vec
    my_vector: Vec<u32>,
}
/* --snip-- */

#[ink(storage)]
pub struct MyContract {
    // Store some AccountId
    my_account: AccountId,
    // Store some Balance
    my_balance: Balance,
    // Store some Hash
    my_hash: Hash,
}
/* --snip-- */

#[ink(storage)]
#[derive(Default)]
pub struct Mappings {
    /// Mapping from owner to number of owned token.
    balances: Mapping<AccountId, Balance>,
    /// Mapping from owner to aliases.
    names: Mapping<AccountId, Vec<String>>,
}

[dependencies]
...
scale-info = { version = "2.6", default-features = false, features = ["derive"]}
scale = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive"] }

#[derive(scale::Encode, scale::Decode, Debug)]
#[cfg_attr(feature = "std", derive(StorageLayout, scale_info::TypeInfo))]
pub enum Status {
    /// An auction has not started yet.
    NotStarted,
    /// We are in the starting period of the auction, collecting initial bids.
    OpeningPeriod,
}

mod MyContract {
    use ink::prelude::string::String;
    use ink::prelude::vec::Vec;
 
    // Định nghĩa struct lưu thông tin Status 
    #[derive(scale::Encode, scale::Decode, Debug)]
    #[cfg_attr(feature = "std", derive(StorageLayout, scale_info::TypeInfo))]
    pub struct Auction {
        /// Branded name of the auction event.
        name: String,
        /// Some hash identifying the auction subject.
        subject: Hash,
        /// Auction status.
        status: Status, // Enum: Usage shown in next section
        /// Candle auction can have no winner.
        /// If auction is finalized, that means that the winner is determined.
        finalized: bool,
        /// vector
        vector: Vec<u8>,
    }
 
    #[ink(storage)]
    pub struct MyContract {
        // Store Auctions in a vec
        auctions: Vec<Auction>,
    }
}
 

fn <tên hàm> (&mut self, ...) {
    ... 
    }

impl MyContract {
 
    #[ink(message)]
    pub fn my_setter(&mut self, new_value: u32) {
        self.my_number = new_value;
    }
}

fn <tên hàm> (&self, ...) {
    ... 
    }

impl MyContract {
 
    #[ink(message)]
    pub fn my_setter(&mut self, new_value: u32) {
        self.my_number = new_value;
    }
}

#[ink(event)]
pub struct Released {
    value: Balance,
    to: AccountId,
}

#[ink(message)]
pub fn release(&mut self) -> Result<(), Error> {
    ...
 
    self.env().emit_event(Released {
        value: releasable,
        to: self.beneficiary,
    });
 
    Ok(())
}

#[derive(Debug, PartialEq, Eq)]
#[ink::scale_derive(Encode, Decode, TypeInfo)]
pub enum Error {
    InvalidBeneficiary,
    ZeroReleasableBalance,
}

#[ink(message)]
pub fn release(&mut self) -> Result<(), Error> {
    let releasable = self.releasable_balance();
    if releasable == 0 {
        return Err(Error::ZeroReleasableBalance)
    }
    ...
    Ok(())
}