set_balance()

 // 명하
        #[pallet::weight] 
        pub fn set_balance(
            origin: OriginFor<T>, 
            who: <T::LookUp as StaticLookUp>::Source, 
            #[pallet::compact] new_free: T::Balance, 
            #[pallet:compact] new_reserved: T::Balance,
        ) {
                // check the origin === root
                ensure_root(origin)?;
                let who = T::LookUp::lookup(who)?;
                let existential_deposit = T::ExistentialDeposit::get();

                // get current target and his balance
                let wipeout = new_free + new_reserved < existential_deposit;
                let new_free = if wipeout {Zero::zero()} else {new_free};
                let new_reseved = if wipeout {Zero::zero()} else {new_reserved};

                // calculate new free/reseved balance > existential deposit
                let (old_free, old_reserved) = Self::mutate_account(&who, |account| {
                    let old_free = account.free;
                    let old_reserved = account.reseved;

                    account.free = new_free;
                    account.reserved - new_reserved;

                    (old_free, old_reserved)
                })?;

                // change total issuance
                if new_free >  old_free {
                    mem::drop(PositiveImbalance::<T, I>::new(new_free - old_free));
                }else if new_free < old_free {
                    mem::drop(NegativeImbalance::<T, I>::new(old_free - new_free));
                }


                if new_reseved > old_reserved {
                    mem::drop(PositiveImbalance::<T, I>::new(new_reseved - old_reserved));
                }else if new_reseved < old_reserved {
                    mem::drop(NegativeImbalance::<T, I>::new(old_reserved - new_reseved));
                }

                // trigger deposit event
                Self::deposit_event(Event::BalacneSet {who, free:new_free, reseved:new_reserved });
                Ok(().into())
            }

• set_balance_creating(), set_balance_killing()

// Storage: System Account (r:1 w:1)
    fn set_balance_creating() -> Weight {
        (22_279_000 as Weight)
            .saturating_add(T::DbWeight::get().reads(1 as Weight))
            .saturating_add(T::DbWeight::get().writes(1 as Weight))
    }
    // Storage: System Account (r:1 w:1)
    fn set_balance_killing() -> Weight {
        (25_488_000 as Weight)
            .saturating_add(T::DbWeight::get().reads(1 as Weight))
            .saturating_add(T::DbWeight::get().writes(1 as Weight))
    }

• #[pallet::compact] : 좀 더 메모리를 적게 차지하는 방식으로 인코딩하고 싶을 때 사용
• <T::LookUp as StaticLookUp>::Source : Source 타입을 받아서 AccountId로 바꿀 수 있게 해줌
• ensure_root() : origin이 root이면 ok, 아니면 error 리턴
• T::ExistentialDeposit::get(); : exsistentialDeposit 값 리턴
• Zefo::zero() : existential deposit 보다 작은 값 넣으려고 하면 아예 0으로 설정해버림
• account 는 갑자기 어디서 튀어나온 거?

2. Internal/External Functions

usable_balance()

 pub fn usable_balance(who: impl sp_std::borrow::Borrow<T::AccountId>) -> T::Balance {
            // usable balance 가져오기
            self.account(whoe.borrow()).usable(Reasons::Misc)

        }

• self.account:는 어디에 선언되어있는거?

mutate_account()

// 명하
        // account의 balance 값을 업데이트. 기존에 있는 계정인지 헤크해야 함
        pub fn mutate_account<R>(who:&T::AccountId, f: impl FnOnce(&mut AccountData<T::Balance> -> R)) -> Result<R, DispatchError> {
            Self::try_mutate_account(who, |a, _| -> Result<R, DispatchError> {
                Ok(f(a))
            })
        }

• FnOnce: 한 번만 호출될 수 있음
• |a,_|: a는 또 어디서 튀어나온거

러스트에는 두 가지 종류의 상수 타입이 있는데,

1. const는

변하지 않는 값을 담는 타입이고,

2. static은

• 'static 라이프타임을 가지고 있는
• 값이 변할 수도 있는 변수를 담는 타입입니다.

static 키워드는 글로벌 변수를 선언하는데, 이 변수들은 read-only 메모리 영역에 위치하기 때문에 값을 수정하는 것이 금지됩니다.

사용법

1. 참조값

참조 라이프타임을 나타내는 'static은 해당 참조가 가리키는 데이터가 프로그램 전체 라이프타임 동안 유효하다는 것을 의미합니다.

static NUM: i32 = 18;

let s: &'static str = "hello world";

2. Trait bound

만약에 어떠한 레퍼런스의 라이프타임이 'static 으로 명시되어 있다면 해당 레퍼런스는 프로그램의 전체 실행 시간 동안 존재하는 데이터를 레퍼런스 한다는 의미가 됩니다. 그래서 해당 값을 받는 쪽에서 원하는 만큼 해당 타입을 사용할 수 있습니다. 소유한 데이터를 넘길 때 'static 라이프타임 바운드를 갖습니다.

fn print_it( input: impl Debug + 'static ) {
    println!( "'static value passed in is: {:?}", input );
}

fn main() {
    // i is owned and contains no references, thus it's 'static:
    let i = 5;
    print_it(i);

    // oops, &i only has the lifetime defined by the scope of
    // main(), so it's not 'static:
    print_it(&i);
}

Balances Pallet

account와 balances를 다루는 기능 제공

기능

• free balances 가져오고 설정하기
• 전체, reseved, unreserved balances 검색
• reserved balances을 해당 계좌로 보내기
• 계좌들 사이의 송금 not reseved
• 계좌 잔액 줄이기
• 계좌 생성과 제거
• 총 발행량 관리
• 잠금 설정 관리

용어

• 존재예금Existential Deposit : 한 계좌를 만들고 유지하기 위해 필요한 최소한의 잔액. 이를 통해 스토리지를 채우는 "먼지 계정"들을 방지할 수 있다. 무료 + 예약된 잔액이 이 금액보다 낮아지면 그 계좌는 죽은 것으로 여겨진다. 기능뿐만 아니라 이전 내역까지 체인 스토리지에서 지워진다.

• 총 발행량: 시스템에 있는 통화의 총 발행량

• 계정 수익 : 논스를 재설정해서 계정을 삭제하는 행동. 총 잔액이 0이 된 후에 발생한다(엄격하게 말하자면, 존재 예그몹다 적은 경우에)

• 무료 잔고 : 예약되지 않은 잔고의 비율. 무료잔고는 대부분의 동작에 중요한 유일한 잔고이다.

• 예약 잔고 : 예약 잔고는 여전히 계좌 주인에게 속해 있지만, 지연되어 있다. 예약 잔고는 여전히 지워질 수 있지만, 오직 무료 잔고가 지워진 후에만 가능하다.

• 불균형 : 일부 자금이 동일하고 반대되는 회계(총 발행 잔액과 계정 잔액의 차) 없이 신용 또는 차변되는 조건. 불균형을 초래하는 함수는 런타임 로직 안에서 관리할 수 있는 Imbalance trait 객체를 반환(불균형이 해소되면 총 발행과 같은 book-keeping을 자동으로 유지해야 함)

• 잠금: 특정 블록 번호까지 한 계정의 free balances를 특정량 잠그는 것. 동일한 자본에 대해 여러 개의 잠금이 가능하므로 스택이 아니라 오버레이된다.

구현

Balances 팔레트는 다음과 같은 trait들의 구현을 제공하므로 중복해서 구현할 필요 없다.

• Currency(frame_support::traits::Currency) : 복제 가능한 자산 시스템을 다루는 함수
• ReservableCurrency(frame_support::traits::ReservableCurrency)
• NamedReservableCurrency(frame_support::traits::NamedReservableCurrency) : 한 계정에 예약될 수 있는 자산들을 다루는 함수
• LockableCurrency(frame_support::traits::LockableCurrency) : 유동성 제한을 허용하는 계정들을 다루는 함수
• Imbalance(frame_support::traits::Imbalance) : 총 발행량과 계정 잔액의 불균형을 다루는 함수. 함수가 새로운 기금을 만들거나 어떤 기금을 파괴할 때 사용되어야만 함

인터페이스

Dispatchable Functions

• transfer - 무료 잔액(liquid free balance)을 다른 계정으로 옮김
• set_balance - 주어진 계정의 잔액을 설정. 반드시 루트가 호출해야만 함

사용법

FRAME 예시

• Contract Pallet는 가스비 지불을 위해Currency trait을 사용하고, 그 타입은 Currency에서 상속받음

use frame_support::traits::Currency;
pub trait Config: frame_system::Config {
     type Currency: Currency<Self::AccountId>;
}

pub type BalanceOf<T> = <<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
pub type NegativeImbalanceOf<T> = <<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::NegativeImbalance;

fn main() {}

• Staking pallet는 숨겨진 계정의 자금을 잠그기 위해 LockableCurrency trait을 사용

use frame_support::traits::{WithdrawReasons, LockableCurrency};
use sp_runtime::traits::Bounded;
pub trait Config: frame_system::Config {
     type Currency: LockableCurrency<Self::AccountId, Moment=Self::BlockNumber>;
 }
struct StakingLedger<T: Config> {
     stash: <T as frame_system::Config>::AccountId,
     total: <<T as Config>::Currency as frame_support::traits::Currency<<T as frame_system::Config>::AccountId>>::Balance,
     phantom: std::marker::PhantomData<T>,
 }
 const STAKING_ID: [u8; 8] = *b"staking ";

 fn update_ledger<T: Config>(
     controller: &T::AccountId,
     ledger: &StakingLedger<T>
 ) {
     T::Currency::set_lock(
         STAKING_ID,
         &ledger.stash,
         ledger.total,
         WithdrawReasons::all()
     );
     // <Ledger<T>>::insert(controller, ledger); 
    // Commented out as we don't have access to Staking's storage here.
 }
 fn main() {}

초기 설정

Balances pallet는 GenesisConfig에 의존

Assumptions

모든 계정의 총 발행된 잔액의 합은Config::Balance::max_value() 보다 작아야 함

실제 코드

#![cfg_attr(not(feature = "std"), no_std)]

#[macro_use]
mod tests;
mod benchmarking;
mod tests_composite;
mod tests_local;
#[cfg(test)]
mod tests_reentrancy;
pub mod weights;

pub use self::imbalances::{NegativeImbalance, PositiveImbalance};
use codec::{Codec, Decode, Encode, MaxEncodedLen};
#[cfg(feature = "std")]
use frame_support::traits::GenesisBuild;
use frame_support::{
    ensure,
    pallet_prelude::DispatchResult,
    traits::{
        tokens::{fungible, BalanceStatus as Status, DepositConsequence, WithdrawConsequence},
        Currency, DefensiveSaturating, ExistenceRequirement,
        ExistenceRequirement::{AllowDeath, KeepAlive},
        Get, Imbalance, LockIdentifier, LockableCurrency, NamedReservableCurrency, OnUnbalanced,
        ReservableCurrency, SignedImbalance, StoredMap, TryDrop, WithdrawReasons,
    },
    WeakBoundedVec,
};
use frame_system as system;
use scale_info::TypeInfo;
use sp_runtime::{
    traits::{
        AtLeast32BitUnsigned, Bounded, CheckedAdd, CheckedSub, MaybeSerializeDeserialize,
        Saturating, StaticLookup, Zero,
    },
    ArithmeticError, DispatchError, RuntimeDebug,
};
use sp_std::{cmp, fmt::Debug, mem, ops::BitOr, prelude::*, result};
pub use weights::WeightInfo;

pub use pallet::*;

#[frame_support::pallet]
pub mod pallet {
    use super::*;
    use frame_support::pallet_prelude::*;
    use frame_system::pallet_prelude::*;

    #[pallet::config]
    pub trait Config<I: 'static = ()>: frame_system::Config {
        /// The balance of an account.
        type Balance: Parameter
            + Member
            + AtLeast32BitUnsigned
            + Codec
            + Default
            + Copy
            + MaybeSerializeDeserialize
            + Debug
            + MaxEncodedLen
            + TypeInfo;

        /// Handler for the unbalanced reduction when removing a dust account.
        type DustRemoval: OnUnbalanced<NegativeImbalance<Self, I>>;

        /// The overarching event type.
        type Event: From<Event<Self, I>> + IsType<<Self as frame_system::Config>::Event>;

        /// The minimum amount required to keep an account open.
        #[pallet::constant]
        type ExistentialDeposit: Get<Self::Balance>;

        /// The means of storing the balances of an account.
        type AccountStore: StoredMap<Self::AccountId, AccountData<Self::Balance>>;

        /// Weight information for extrinsics in this pallet.
        type WeightInfo: WeightInfo;

        /// The maximum number of locks that should exist on an account.
        /// Not strictly enforced, but used for weight estimation.
        #[pallet::constant]
        type MaxLocks: Get<u32>;

        /// The maximum number of named reserves that can exist on an account.
        #[pallet::constant]
        type MaxReserves: Get<u32>;

        /// The id type for named reserves.
        type ReserveIdentifier: Parameter + Member + MaxEncodedLen + Ord + Copy;
    }

    #[pallet::pallet]
    #[pallet::generate_store(pub(super) trait Store)]
    pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);

    #[pallet::call]
    impl<T: Config<I>, I: 'static> Pallet<T, I> {
        /// Transfer some liquid free balance to another account.
        ///
        /// `transfer` will set the `FreeBalance` of the sender and receiver.
        /// If the sender's account is below the existential deposit as a result
        /// of the transfer, the account will be reaped.
        ///
        /// The dispatch origin for this call must be `Signed` by the transactor.
        ///
        /// # <weight>
        /// - Dependent on arguments but not critical, given proper implementations for input config
        ///   types. See related functions below.
        /// - It contains a limited number of reads and writes internally and no complex
        ///   computation.
        ///
        /// Related functions:
        ///
        ///   - `ensure_can_withdraw` is always called internally but has a bounded complexity.
        ///   - Transferring balances to accounts that did not exist before will cause
        ///     `T::OnNewAccount::on_new_account` to be called.
        ///   - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.
        ///   - `transfer_keep_alive` works the same way as `transfer`, but has an additional check
        ///     that the transfer will not kill the origin account.
        /// ---------------------------------
        /// - Origin account is already in memory, so no DB operations for them.
        /// # </weight>
        #[pallet::weight(T::WeightInfo::transfer())]
        pub fn transfer(
            origin: OriginFor<T>,
            dest: <T::Lookup as StaticLookup>::Source,
            #[pallet::compact] value: T::Balance,
        ) -> DispatchResultWithPostInfo {
            let transactor = ensure_signed(origin)?;
            let dest = T::Lookup::lookup(dest)?;
            <Self as Currency<_>>::transfer(
                &transactor,
                &dest,
                value,
                ExistenceRequirement::AllowDeath,
            )?;
            Ok(().into())
        }

        /// Set the balances of a given account.
        ///
        /// This will alter `FreeBalance` and `ReservedBalance` in storage. it will
        /// also alter the total issuance of the system (`TotalIssuance`) appropriately.
        /// If the new free or reserved balance is below the existential deposit,
        /// it will reset the account nonce (`frame_system::AccountNonce`).
        ///
        /// The dispatch origin for this call is `root`.
        #[pallet::weight(
            T::WeightInfo::set_balance_creating() // Creates a new account.
                .max(T::WeightInfo::set_balance_killing()) // Kills an existing account.
        )]
        pub fn set_balance(
            origin: OriginFor<T>,
            who: <T::Lookup as StaticLookup>::Source,
            #[pallet::compact] new_free: T::Balance,
            #[pallet::compact] new_reserved: T::Balance,
        ) -> DispatchResultWithPostInfo {
            ensure_root(origin)?;
            let who = T::Lookup::lookup(who)?;
            let existential_deposit = T::ExistentialDeposit::get();

            let wipeout = new_free + new_reserved < existential_deposit;
            let new_free = if wipeout { Zero::zero() } else { new_free };
            let new_reserved = if wipeout { Zero::zero() } else { new_reserved };

            // First we try to modify the account's balance to the forced balance.
            let (old_free, old_reserved) = Self::mutate_account(&who, |account| {
                let old_free = account.free;
                let old_reserved = account.reserved;

                account.free = new_free;
                account.reserved = new_reserved;

                (old_free, old_reserved)
            })?;

            // This will adjust the total issuance, which was not done by the `mutate_account`
            // above.
            if new_free > old_free {
                mem::drop(PositiveImbalance::<T, I>::new(new_free - old_free));
            } else if new_free < old_free {
                mem::drop(NegativeImbalance::<T, I>::new(old_free - new_free));
            }

            if new_reserved > old_reserved {
                mem::drop(PositiveImbalance::<T, I>::new(new_reserved - old_reserved));
            } else if new_reserved < old_reserved {
                mem::drop(NegativeImbalance::<T, I>::new(old_reserved - new_reserved));
            }

            Self::deposit_event(Event::BalanceSet { who, free: new_free, reserved: new_reserved });
            Ok(().into())
        }

        /// Exactly as `transfer`, except the origin must be root and the source account may be
        /// specified.
        /// # <weight>
        /// - Same as transfer, but additional read and write because the source account is not
        ///   assumed to be in the overlay.
        /// # </weight>
        #[pallet::weight(T::WeightInfo::force_transfer())]
        pub fn force_transfer(
            origin: OriginFor<T>,
            source: <T::Lookup as StaticLookup>::Source,
            dest: <T::Lookup as StaticLookup>::Source,
            #[pallet::compact] value: T::Balance,
        ) -> DispatchResultWithPostInfo {
            ensure_root(origin)?;
            let source = T::Lookup::lookup(source)?;
            let dest = T::Lookup::lookup(dest)?;
            <Self as Currency<_>>::transfer(
                &source,
                &dest,
                value,
                ExistenceRequirement::AllowDeath,
            )?;
            Ok(().into())
        }

        /// Same as the [`transfer`] call, but with a check that the transfer will not kill the
        /// origin account.
        ///
        /// 99% of the time you want [`transfer`] instead.
        ///
        /// [`transfer`]: struct.Pallet.html#method.transfer
        #[pallet::weight(T::WeightInfo::transfer_keep_alive())]
        pub fn transfer_keep_alive(
            origin: OriginFor<T>,
            dest: <T::Lookup as StaticLookup>::Source,
            #[pallet::compact] value: T::Balance,
        ) -> DispatchResultWithPostInfo {
            let transactor = ensure_signed(origin)?;
            let dest = T::Lookup::lookup(dest)?;
            <Self as Currency<_>>::transfer(&transactor, &dest, value, KeepAlive)?;
            Ok(().into())
        }

        /// Transfer the entire transferable balance from the caller account.
        ///
        /// NOTE: This function only attempts to transfer _transferable_ balances. This means that
        /// any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be
        /// transferred by this function. To ensure that this function results in a killed account,
        /// you might need to prepare the account by removing any reference counters, storage
        /// deposits, etc...
        ///
        /// The dispatch origin of this call must be Signed.
        ///
        /// - `dest`: The recipient of the transfer.
        /// - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all
        ///   of the funds the account has, causing the sender account to be killed (false), or
        ///   transfer everything except at least the existential deposit, which will guarantee to
        ///   keep the sender account alive (true). # <weight>
        /// - O(1). Just like transfer, but reading the user's transferable balance first.
        ///   #</weight>
        #[pallet::weight(T::WeightInfo::transfer_all())]
        pub fn transfer_all(
            origin: OriginFor<T>,
            dest: <T::Lookup as StaticLookup>::Source,
            keep_alive: bool,
        ) -> DispatchResult {
            use fungible::Inspect;
            let transactor = ensure_signed(origin)?;
            let reducible_balance = Self::reducible_balance(&transactor, keep_alive);
            let dest = T::Lookup::lookup(dest)?;
            let keep_alive = if keep_alive { KeepAlive } else { AllowDeath };
            <Self as Currency<_>>::transfer(&transactor, &dest, reducible_balance, keep_alive)?;
            Ok(())
        }

        /// Unreserve some balance from a user by force.
        ///
        /// Can only be called by ROOT.
        #[pallet::weight(T::WeightInfo::force_unreserve())]
        pub fn force_unreserve(
            origin: OriginFor<T>,
            who: <T::Lookup as StaticLookup>::Source,
            amount: T::Balance,
        ) -> DispatchResult {
            ensure_root(origin)?;
            let who = T::Lookup::lookup(who)?;
            let _leftover = <Self as ReservableCurrency<_>>::unreserve(&who, amount);
            Ok(())
        }
    }

    #[pallet::event]
    #[pallet::generate_deposit(pub(super) fn deposit_event)]
    pub enum Event<T: Config<I>, I: 'static = ()> {
        /// An account was created with some free balance.
        Endowed { account: T::AccountId, free_balance: T::Balance },
        /// An account was removed whose balance was non-zero but below ExistentialDeposit,
        /// resulting in an outright loss.
        DustLost { account: T::AccountId, amount: T::Balance },
        /// Transfer succeeded.
        Transfer { from: T::AccountId, to: T::AccountId, amount: T::Balance },
        /// A balance was set by root.
        BalanceSet { who: T::AccountId, free: T::Balance, reserved: T::Balance },
        /// Some balance was reserved (moved from free to reserved).
        Reserved { who: T::AccountId, amount: T::Balance },
        /// Some balance was unreserved (moved from reserved to free).
        Unreserved { who: T::AccountId, amount: T::Balance },
        /// Some balance was moved from the reserve of the first account to the second account.
        /// Final argument indicates the destination balance type.
        ReserveRepatriated {
            from: T::AccountId,
            to: T::AccountId,
            amount: T::Balance,
            destination_status: Status,
        },
        /// Some amount was deposited (e.g. for transaction fees).
        Deposit { who: T::AccountId, amount: T::Balance },
        /// Some amount was withdrawn from the account (e.g. for transaction fees).
        Withdraw { who: T::AccountId, amount: T::Balance },
        /// Some amount was removed from the account (e.g. for misbehavior).
        Slashed { who: T::AccountId, amount: T::Balance },
    }

    #[pallet::error]
    pub enum Error<T, I = ()> {
        /// Vesting balance too high to send value
        VestingBalance,
        /// Account liquidity restrictions prevent withdrawal
        LiquidityRestrictions,
        /// Balance too low to send value
        InsufficientBalance,
        /// Value too low to create account due to existential deposit
        ExistentialDeposit,
        /// Transfer/payment would kill account
        KeepAlive,
        /// A vesting schedule already exists for this account
        ExistingVestingSchedule,
        /// Beneficiary account must pre-exist
        DeadAccount,
        /// Number of named reserves exceed MaxReserves
        TooManyReserves,
    }

    /// The total units issued in the system.
    #[pallet::storage]
    #[pallet::getter(fn total_issuance)]
    pub type TotalIssuance<T: Config<I>, I: 'static = ()> = StorageValue<_, T::Balance, ValueQuery>;

    /// The Balances pallet example of storing the balance of an account.
    ///
    /// # Example
    ///
    /// ```nocompile
    ///  impl pallet_balances::Config for Runtime {
    ///    type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>
    ///  }
    /// ```
    ///
    /// You can also store the balance of an account in the `System` pallet.
    ///
    /// # Example
    ///
    /// ```nocompile
    ///  impl pallet_balances::Config for Runtime {
    ///   type AccountStore = System
    ///  }
    /// ```
    ///
    /// But this comes with tradeoffs, storing account balances in the system pallet stores
    /// `frame_system` data alongside the account data contrary to storing account balances in the
    /// `Balances` pallet, which uses a `StorageMap` to store balances data only.
    /// NOTE: This is only used in the case that this pallet is used to store balances.
    #[pallet::storage]
    pub type Account<T: Config<I>, I: 'static = ()> =
        StorageMap<_, Blake2_128Concat, T::AccountId, AccountData<T::Balance>, ValueQuery>;

    /// Any liquidity locks on some account balances.
    /// NOTE: Should only be accessed when setting, changing and freeing a lock.
    #[pallet::storage]
    #[pallet::getter(fn locks)]
    pub type Locks<T: Config<I>, I: 'static = ()> = StorageMap<
        _,
        Blake2_128Concat,
        T::AccountId,
        WeakBoundedVec<BalanceLock<T::Balance>, T::MaxLocks>,
        ValueQuery,
    >;

    /// Named reserves on some account balances.
    #[pallet::storage]
    #[pallet::getter(fn reserves)]
    pub type Reserves<T: Config<I>, I: 'static = ()> = StorageMap<
        _,
        Blake2_128Concat,
        T::AccountId,
        BoundedVec<ReserveData<T::ReserveIdentifier, T::Balance>, T::MaxReserves>,
        ValueQuery,
    >;

    /// Storage version of the pallet.
    ///
    /// This is set to v2.0.0 for new networks.
    #[pallet::storage]
    pub(super) type StorageVersion<T: Config<I>, I: 'static = ()> =
        StorageValue<_, Releases, ValueQuery>;

    #[pallet::genesis_config]
    pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
        pub balances: Vec<(T::AccountId, T::Balance)>,
    }

    #[cfg(feature = "std")]
    impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {
        fn default() -> Self {
            Self { balances: Default::default() }
        }
    }

    #[pallet::genesis_build]
    impl<T: Config<I>, I: 'static> GenesisBuild<T, I> for GenesisConfig<T, I> {
        fn build(&self) {
            let total = self.balances.iter().fold(Zero::zero(), |acc: T::Balance, &(_, n)| acc + n);
            <TotalIssuance<T, I>>::put(total);

            <StorageVersion<T, I>>::put(Releases::V2_0_0);

            for (_, balance) in &self.balances {
                assert!(
                    *balance >= <T as Config<I>>::ExistentialDeposit::get(),
                    "the balance of any account should always be at least the existential deposit.",
                )
            }

            // ensure no duplicates exist.
            let endowed_accounts = self
                .balances
                .iter()
                .map(|(x, _)| x)
                .cloned()
                .collect::<std::collections::BTreeSet<_>>();

            assert!(
                endowed_accounts.len() == self.balances.len(),
                "duplicate balances in genesis."
            );

            for &(ref who, free) in self.balances.iter() {
                assert!(T::AccountStore::insert(who, AccountData { free, ..Default::default() })
                    .is_ok());
            }
        }
    }
}

#[cfg(feature = "std")]
impl<T: Config<I>, I: 'static> GenesisConfig<T, I> {
    /// Direct implementation of `GenesisBuild::build_storage`.
    ///
    /// Kept in order not to break dependency.
    pub fn build_storage(&self) -> Result<sp_runtime::Storage, String> {
        <Self as GenesisBuild<T, I>>::build_storage(self)
    }

    /// Direct implementation of `GenesisBuild::assimilate_storage`.
    ///
    /// Kept in order not to break dependency.
    pub fn assimilate_storage(&self, storage: &mut sp_runtime::Storage) -> Result<(), String> {
        <Self as GenesisBuild<T, I>>::assimilate_storage(self, storage)
    }
}

/// Simplified reasons for withdrawing balance.
#[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
pub enum Reasons {
    /// Paying system transaction fees.
    Fee = 0,
    /// Any reason other than paying system transaction fees.
    Misc = 1,
    /// Any reason at all.
    All = 2,
}

impl From<WithdrawReasons> for Reasons {
    fn from(r: WithdrawReasons) -> Reasons {
        if r == WithdrawReasons::TRANSACTION_PAYMENT {
            Reasons::Fee
        } else if r.contains(WithdrawReasons::TRANSACTION_PAYMENT) {
            Reasons::All
        } else {
            Reasons::Misc
        }
    }
}

impl BitOr for Reasons {
    type Output = Reasons;
    fn bitor(self, other: Reasons) -> Reasons {
        if self == other {
            return self
        }
        Reasons::All
    }
}

/// A single lock on a balance. There can be many of these on an account and they "overlap", so the
/// same balance is frozen by multiple locks.
#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
pub struct BalanceLock<Balance> {
    /// An identifier for this lock. Only one lock may be in existence for each identifier.
    pub id: LockIdentifier,
    /// The amount which the free balance may not drop below when this lock is in effect.
    pub amount: Balance,
    /// If true, then the lock remains in effect even for payment of transaction fees.
    pub reasons: Reasons,
}

/// Store named reserved balance.
#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
pub struct ReserveData<ReserveIdentifier, Balance> {
    /// The identifier for the named reserve.
    pub id: ReserveIdentifier,
    /// The amount of the named reserve.
    pub amount: Balance,
}

/// All balance information for an account.
#[derive(Encode, Decode, Clone, PartialEq, Eq, Default, RuntimeDebug, MaxEncodedLen, TypeInfo)]
pub struct AccountData<Balance> {
    /// Non-reserved part of the balance. There may still be restrictions on this, but it is the
    /// total pool what may in principle be transferred, reserved and used for tipping.
    ///
    /// This is the only balance that matters in terms of most operations on tokens. It
    /// alone is used to determine the balance when in the contract execution environment.
    pub free: Balance,
    /// Balance which is reserved and may not be used at all.
    ///
    /// This can still get slashed, but gets slashed last of all.
    ///
    /// This balance is a 'reserve' balance that other subsystems use in order to set aside tokens
    /// that are still 'owned' by the account holder, but which are suspendable.
    /// This includes named reserve and unnamed reserve.
    pub reserved: Balance,
    /// The amount that `free` may not drop below when withdrawing for *anything except transaction
    /// fee payment*.
    pub misc_frozen: Balance,
    /// The amount that `free` may not drop below when withdrawing specifically for transaction
    /// fee payment.
    pub fee_frozen: Balance,
}

impl<Balance: Saturating + Copy + Ord> AccountData<Balance> {
    /// How much this account's balance can be reduced for the given `reasons`.
    fn usable(&self, reasons: Reasons) -> Balance {
        self.free.saturating_sub(self.frozen(reasons))
    }
    /// The amount that this account's free balance may not be reduced beyond for the given
    /// `reasons`.
    fn frozen(&self, reasons: Reasons) -> Balance {
        match reasons {
            Reasons::All => self.misc_frozen.max(self.fee_frozen),
            Reasons::Misc => self.misc_frozen,
            Reasons::Fee => self.fee_frozen,
        }
    }
    /// The total balance in this account including any that is reserved and ignoring any frozen.
    fn total(&self) -> Balance {
        self.free.saturating_add(self.reserved)
    }
}

// A value placed in storage that represents the current version of the Balances storage.
// This value is used by the `on_runtime_upgrade` logic to determine whether we run
// storage migration logic. This should match directly with the semantic versions of the Rust crate.
#[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
enum Releases {
    V1_0_0,
    V2_0_0,
}

impl Default for Releases {
    fn default() -> Self {
        Releases::V1_0_0
    }
}

pub struct DustCleaner<T: Config<I>, I: 'static = ()>(
    Option<(T::AccountId, NegativeImbalance<T, I>)>,
);

impl<T: Config<I>, I: 'static> Drop for DustCleaner<T, I> {
    fn drop(&mut self) {
        if let Some((who, dust)) = self.0.take() {
            Pallet::<T, I>::deposit_event(Event::DustLost { account: who, amount: dust.peek() });
            T::DustRemoval::on_unbalanced(dust);
        }
    }
}

impl<T: Config<I>, I: 'static> Pallet<T, I> {
    /// Get the free balance of an account.
    pub fn free_balance(who: impl sp_std::borrow::Borrow<T::AccountId>) -> T::Balance {
        Self::account(who.borrow()).free
    }

    /// Get the balance of an account that can be used for transfers, reservations, or any other
    /// non-locking, non-transaction-fee activity. Will be at most `free_balance`.
    pub fn usable_balance(who: impl sp_std::borrow::Borrow<T::AccountId>) -> T::Balance {
        Self::account(who.borrow()).usable(Reasons::Misc)
    }

    /// Get the balance of an account that can be used for paying transaction fees (not tipping,
    /// or any other kind of fees, though). Will be at most `free_balance`.
    pub fn usable_balance_for_fees(who: impl sp_std::borrow::Borrow<T::AccountId>) -> T::Balance {
        Self::account(who.borrow()).usable(Reasons::Fee)
    }

    /// Get the reserved balance of an account.
    pub fn reserved_balance(who: impl sp_std::borrow::Borrow<T::AccountId>) -> T::Balance {
        Self::account(who.borrow()).reserved
    }

    /// Get both the free and reserved balances of an account.
    fn account(who: &T::AccountId) -> AccountData<T::Balance> {
        T::AccountStore::get(who)
    }

    /// Handles any steps needed after mutating an account.
    ///
    /// This includes DustRemoval unbalancing, in the case than the `new` account's total balance
    /// is non-zero but below ED.
    ///
    /// Returns two values:
    /// - `Some` containing the the `new` account, iff the account has sufficient balance.
    /// - `Some` containing the dust to be dropped, iff some dust should be dropped.
    fn post_mutation(
        _who: &T::AccountId,
        new: AccountData<T::Balance>,
    ) -> (Option<AccountData<T::Balance>>, Option<NegativeImbalance<T, I>>) {
        let total = new.total();
        if total < T::ExistentialDeposit::get() {
            if total.is_zero() {
                (None, None)
            } else {
                (None, Some(NegativeImbalance::new(total)))
            }
        } else {
            (Some(new), None)
        }
    }

    fn deposit_consequence(
        _who: &T::AccountId,
        amount: T::Balance,
        account: &AccountData<T::Balance>,
        mint: bool,
    ) -> DepositConsequence {
        if amount.is_zero() {
            return DepositConsequence::Success
        }

        if mint && TotalIssuance::<T, I>::get().checked_add(&amount).is_none() {
            return DepositConsequence::Overflow
        }

        let new_total_balance = match account.total().checked_add(&amount) {
            Some(x) => x,
            None => return DepositConsequence::Overflow,
        };

        if new_total_balance < T::ExistentialDeposit::get() {
            return DepositConsequence::BelowMinimum
        }

        // NOTE: We assume that we are a provider, so don't need to do any checks in the
        // case of account creation.

        DepositConsequence::Success
    }

    fn withdraw_consequence(
        who: &T::AccountId,
        amount: T::Balance,
        account: &AccountData<T::Balance>,
    ) -> WithdrawConsequence<T::Balance> {
        if amount.is_zero() {
            return WithdrawConsequence::Success
        }

        if TotalIssuance::<T, I>::get().checked_sub(&amount).is_none() {
            return WithdrawConsequence::Underflow
        }

        let new_total_balance = match account.total().checked_sub(&amount) {
            Some(x) => x,
            None => return WithdrawConsequence::NoFunds,
        };

        // Provider restriction - total account balance cannot be reduced to zero if it cannot
        // sustain the loss of a provider reference.
        // NOTE: This assumes that the pallet is a provider (which is true). Is this ever changes,
        // then this will need to adapt accordingly.
        let ed = T::ExistentialDeposit::get();
        let success = if new_total_balance < ed {
            if frame_system::Pallet::<T>::can_dec_provider(who) {
                WithdrawConsequence::ReducedToZero(new_total_balance)
            } else {
                return WithdrawConsequence::WouldDie
            }
        } else {
            WithdrawConsequence::Success
        };

        // Enough free funds to have them be reduced.
        let new_free_balance = match account.free.checked_sub(&amount) {
            Some(b) => b,
            None => return WithdrawConsequence::NoFunds,
        };

        // Eventual free funds must be no less than the frozen balance.
        let min_balance = account.frozen(Reasons::All);
        if new_free_balance < min_balance {
            return WithdrawConsequence::Frozen
        }

        success
    }

    /// Mutate an account to some new value, or delete it entirely with `None`. Will enforce
    /// `ExistentialDeposit` law, annulling the account as needed.
    ///
    /// NOTE: Doesn't do any preparatory work for creating a new account, so should only be used
    /// when it is known that the account already exists.
    ///
    /// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
    /// the caller will do this.
    pub fn mutate_account<R>(
        who: &T::AccountId,
        f: impl FnOnce(&mut AccountData<T::Balance>) -> R,
    ) -> Result<R, DispatchError> {
        Self::try_mutate_account(who, |a, _| -> Result<R, DispatchError> { Ok(f(a)) })
    }

    /// Mutate an account to some new value, or delete it entirely with `None`. Will enforce
    /// `ExistentialDeposit` law, annulling the account as needed. This will do nothing if the
    /// result of `f` is an `Err`.
    ///
    /// NOTE: Doesn't do any preparatory work for creating a new account, so should only be used
    /// when it is known that the account already exists.
    ///
    /// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
    /// the caller will do this.
    fn try_mutate_account<R, E: From<DispatchError>>(
        who: &T::AccountId,
        f: impl FnOnce(&mut AccountData<T::Balance>, bool) -> Result<R, E>,
    ) -> Result<R, E> {
        Self::try_mutate_account_with_dust(who, f).map(|(result, dust_cleaner)| {
            drop(dust_cleaner);
            result
        })
    }

    /// Mutate an account to some new value, or delete it entirely with `None`. Will enforce
    /// `ExistentialDeposit` law, annulling the account as needed. This will do nothing if the
    /// result of `f` is an `Err`.
    ///
    /// It returns both the result from the closure, and an optional `DustCleaner` instance which
    /// should be dropped once it is known that all nested mutates that could affect storage items
    /// what the dust handler touches have completed.
    ///
    /// NOTE: Doesn't do any preparatory work for creating a new account, so should only be used
    /// when it is known that the account already exists.
    ///
    /// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
    /// the caller will do this.
    fn try_mutate_account_with_dust<R, E: From<DispatchError>>(
        who: &T::AccountId,
        f: impl FnOnce(&mut AccountData<T::Balance>, bool) -> Result<R, E>,
    ) -> Result<(R, DustCleaner<T, I>), E> {
        let result = T::AccountStore::try_mutate_exists(who, |maybe_account| {
            let is_new = maybe_account.is_none();
            let mut account = maybe_account.take().unwrap_or_default();
            f(&mut account, is_new).map(move |result| {
                let maybe_endowed = if is_new { Some(account.free) } else { None };
                let maybe_account_maybe_dust = Self::post_mutation(who, account);
                *maybe_account = maybe_account_maybe_dust.0;
                (maybe_endowed, maybe_account_maybe_dust.1, result)
            })
        });
        result.map(|(maybe_endowed, maybe_dust, result)| {
            if let Some(endowed) = maybe_endowed {
                Self::deposit_event(Event::Endowed { account: who.clone(), free_balance: endowed });
            }
            let dust_cleaner = DustCleaner(maybe_dust.map(|dust| (who.clone(), dust)));
            (result, dust_cleaner)
        })
    }

    /// Update the account entry for `who`, given the locks.
    fn update_locks(who: &T::AccountId, locks: &[BalanceLock<T::Balance>]) {
        let bounded_locks = WeakBoundedVec::<_, T::MaxLocks>::force_from(
            locks.to_vec(),
            Some("Balances Update Locks"),
        );

        if locks.len() as u32 > T::MaxLocks::get() {
            log::warn!(
                target: "runtime::balances",
                "Warning: A user has more currency locks than expected. \
                A runtime configuration adjustment may be needed."
            );
        }
        // No way this can fail since we do not alter the existential balances.
        let res = Self::mutate_account(who, |b| {
            b.misc_frozen = Zero::zero();
            b.fee_frozen = Zero::zero();
            for l in locks.iter() {
                if l.reasons == Reasons::All || l.reasons == Reasons::Misc {
                    b.misc_frozen = b.misc_frozen.max(l.amount);
                }
                if l.reasons == Reasons::All || l.reasons == Reasons::Fee {
                    b.fee_frozen = b.fee_frozen.max(l.amount);
                }
            }
        });
        debug_assert!(res.is_ok());

        let existed = Locks::<T, I>::contains_key(who);
        if locks.is_empty() {
            Locks::<T, I>::remove(who);
            if existed {
                // TODO: use Locks::<T, I>::hashed_key
                // https://github.com/paritytech/substrate/issues/4969
                system::Pallet::<T>::dec_consumers(who);
            }
        } else {
            Locks::<T, I>::insert(who, bounded_locks);
            if !existed && system::Pallet::<T>::inc_consumers_without_limit(who).is_err() {
                // No providers for the locks. This is impossible under normal circumstances
                // since the funds that are under the lock will themselves be stored in the
                // account and therefore will need a reference.
                log::warn!(
                    target: "runtime::balances",
                    "Warning: Attempt to introduce lock consumer reference, yet no providers. \
                    This is unexpected but should be safe."
                );
            }
        }
    }

    /// Move the reserved balance of one account into the balance of another, according to `status`.
    ///
    /// Is a no-op if:
    /// - the value to be moved is zero; or
    /// - the `slashed` id equal to `beneficiary` and the `status` is `Reserved`.
    fn do_transfer_reserved(
        slashed: &T::AccountId,
        beneficiary: &T::AccountId,
        value: T::Balance,
        best_effort: bool,
        status: Status,
    ) -> Result<T::Balance, DispatchError> {
        if value.is_zero() {
            return Ok(Zero::zero())
        }

        if slashed == beneficiary {
            return match status {
                Status::Free => Ok(Self::unreserve(slashed, value)),
                Status::Reserved => Ok(value.saturating_sub(Self::reserved_balance(slashed))),
            }
        }

        let ((actual, _maybe_one_dust), _maybe_other_dust) = Self::try_mutate_account_with_dust(
            beneficiary,
            |to_account, is_new| -> Result<(T::Balance, DustCleaner<T, I>), DispatchError> {
                ensure!(!is_new, Error::<T, I>::DeadAccount);
                Self::try_mutate_account_with_dust(
                    slashed,
                    |from_account, _| -> Result<T::Balance, DispatchError> {
                        let actual = cmp::min(from_account.reserved, value);
                        ensure!(best_effort || actual == value, Error::<T, I>::InsufficientBalance);
                        match status {
                            Status::Free =>
                                to_account.free = to_account
                                    .free
                                    .checked_add(&actual)
                                    .ok_or(ArithmeticError::Overflow)?,
                            Status::Reserved =>
                                to_account.reserved = to_account
                                    .reserved
                                    .checked_add(&actual)
                                    .ok_or(ArithmeticError::Overflow)?,
                        }
                        from_account.reserved -= actual;
                        Ok(actual)
                    },
                )
            },
        )?;

        Self::deposit_event(Event::ReserveRepatriated {
            from: slashed.clone(),
            to: beneficiary.clone(),
            amount: actual,
            destination_status: status,
        });
        Ok(actual)
    }
}

impl<T: Config<I>, I: 'static> fungible::Inspect<T::AccountId> for Pallet<T, I> {
    type Balance = T::Balance;

    fn total_issuance() -> Self::Balance {
        TotalIssuance::<T, I>::get()
    }
    fn minimum_balance() -> Self::Balance {
        T::ExistentialDeposit::get()
    }
    fn balance(who: &T::AccountId) -> Self::Balance {
        Self::account(who).total()
    }
    fn reducible_balance(who: &T::AccountId, keep_alive: bool) -> Self::Balance {
        let a = Self::account(who);
        // Liquid balance is what is neither reserved nor locked/frozen.
        let liquid = a.free.saturating_sub(a.fee_frozen.max(a.misc_frozen));
        if frame_system::Pallet::<T>::can_dec_provider(who) && !keep_alive {
            liquid
        } else {
            // `must_remain_to_exist` is the part of liquid balance which must remain to keep total
            // over ED.
            let must_remain_to_exist =
                T::ExistentialDeposit::get().saturating_sub(a.total() - liquid);
            liquid.saturating_sub(must_remain_to_exist)
        }
    }
    fn can_deposit(who: &T::AccountId, amount: Self::Balance, mint: bool) -> DepositConsequence {
        Self::deposit_consequence(who, amount, &Self::account(who), mint)
    }
    fn can_withdraw(
        who: &T::AccountId,
        amount: Self::Balance,
    ) -> WithdrawConsequence<Self::Balance> {
        Self::withdraw_consequence(who, amount, &Self::account(who))
    }
}

impl<T: Config<I>, I: 'static> fungible::Mutate<T::AccountId> for Pallet<T, I> {
    fn mint_into(who: &T::AccountId, amount: Self::Balance) -> DispatchResult {
        if amount.is_zero() {
            return Ok(())
        }
        Self::try_mutate_account(who, |account, _is_new| -> DispatchResult {
            Self::deposit_consequence(who, amount, account, true).into_result()?;
            account.free += amount;
            Ok(())
        })?;
        TotalIssuance::<T, I>::mutate(|t| *t += amount);
        Self::deposit_event(Event::Deposit { who: who.clone(), amount });
        Ok(())
    }

    fn burn_from(
        who: &T::AccountId,
        amount: Self::Balance,
    ) -> Result<Self::Balance, DispatchError> {
        if amount.is_zero() {
            return Ok(Self::Balance::zero())
        }
        let actual = Self::try_mutate_account(
            who,
            |account, _is_new| -> Result<T::Balance, DispatchError> {
                let extra = Self::withdraw_consequence(who, amount, account).into_result()?;
                let actual = amount + extra;
                account.free -= actual;
                Ok(actual)
            },
        )?;
        TotalIssuance::<T, I>::mutate(|t| *t -= actual);
        Self::deposit_event(Event::Withdraw { who: who.clone(), amount });
        Ok(actual)
    }
}

impl<T: Config<I>, I: 'static> fungible::Transfer<T::AccountId> for Pallet<T, I> {
    fn transfer(
        source: &T::AccountId,
        dest: &T::AccountId,
        amount: T::Balance,
        keep_alive: bool,
    ) -> Result<T::Balance, DispatchError> {
        let er = if keep_alive { KeepAlive } else { AllowDeath };
        <Self as Currency<T::AccountId>>::transfer(source, dest, amount, er).map(|_| amount)
    }
}

impl<T: Config<I>, I: 'static> fungible::Unbalanced<T::AccountId> for Pallet<T, I> {
    fn set_balance(who: &T::AccountId, amount: Self::Balance) -> DispatchResult {
        Self::mutate_account(who, |account| {
            account.free = amount;
            Self::deposit_event(Event::BalanceSet {
                who: who.clone(),
                free: account.free,
                reserved: account.reserved,
            });
        })?;
        Ok(())
    }

    fn set_total_issuance(amount: Self::Balance) {
        TotalIssuance::<T, I>::mutate(|t| *t = amount);
    }
}

impl<T: Config<I>, I: 'static> fungible::InspectHold<T::AccountId> for Pallet<T, I> {
    fn balance_on_hold(who: &T::AccountId) -> T::Balance {
        Self::account(who).reserved
    }
    fn can_hold(who: &T::AccountId, amount: T::Balance) -> bool {
        let a = Self::account(who);
        let min_balance = T::ExistentialDeposit::get().max(a.frozen(Reasons::All));
        if a.reserved.checked_add(&amount).is_none() {
            return false
        }
        // We require it to be min_balance + amount to ensure that the full reserved funds may be
        // slashed without compromising locked funds or destroying the account.
        let required_free = match min_balance.checked_add(&amount) {
            Some(x) => x,
            None => return false,
        };
        a.free >= required_free
    }
}
impl<T: Config<I>, I: 'static> fungible::MutateHold<T::AccountId> for Pallet<T, I> {
    fn hold(who: &T::AccountId, amount: Self::Balance) -> DispatchResult {
        if amount.is_zero() {
            return Ok(())
        }
        ensure!(Self::can_reserve(who, amount), Error::<T, I>::InsufficientBalance);
        Self::mutate_account(who, |a| {
            a.free -= amount;
            a.reserved += amount;
        })?;
        Ok(())
    }
    fn release(
        who: &T::AccountId,
        amount: Self::Balance,
        best_effort: bool,
    ) -> Result<T::Balance, DispatchError> {
        if amount.is_zero() {
            return Ok(amount)
        }
        // Done on a best-effort basis.
        Self::try_mutate_account(who, |a, _| {
            let new_free = a.free.saturating_add(amount.min(a.reserved));
            let actual = new_free - a.free;
            ensure!(best_effort || actual == amount, Error::<T, I>::InsufficientBalance);
            // ^^^ Guaranteed to be <= amount and <= a.reserved
            a.free = new_free;
            a.reserved = a.reserved.saturating_sub(actual);
            Ok(actual)
        })
    }
    fn transfer_held(
        source: &T::AccountId,
        dest: &T::AccountId,
        amount: Self::Balance,
        best_effort: bool,
        on_hold: bool,
    ) -> Result<Self::Balance, DispatchError> {
        let status = if on_hold { Status::Reserved } else { Status::Free };
        Self::do_transfer_reserved(source, dest, amount, best_effort, status)
    }
}

// wrapping these imbalances in a private module is necessary to ensure absolute privacy
// of the inner member.
mod imbalances {
    use super::{result, Config, Imbalance, RuntimeDebug, Saturating, TryDrop, Zero};
    use frame_support::traits::SameOrOther;
    use sp_std::mem;

    /// Opaque, move-only struct with private fields that serves as a token denoting that
    /// funds have been created without any equal and opposite accounting.
    #[must_use]
    #[derive(RuntimeDebug, PartialEq, Eq)]
    pub struct PositiveImbalance<T: Config<I>, I: 'static = ()>(T::Balance);

    impl<T: Config<I>, I: 'static> PositiveImbalance<T, I> {
        /// Create a new positive imbalance from a balance.
        pub fn new(amount: T::Balance) -> Self {
            PositiveImbalance(amount)
        }
    }

    /// Opaque, move-only struct with private fields that serves as a token denoting that
    /// funds have been destroyed without any equal and opposite accounting.
    #[must_use]
    #[derive(RuntimeDebug, PartialEq, Eq)]
    pub struct NegativeImbalance<T: Config<I>, I: 'static = ()>(T::Balance);

    impl<T: Config<I>, I: 'static> NegativeImbalance<T, I> {
        /// Create a new negative imbalance from a balance.
        pub fn new(amount: T::Balance) -> Self {
            NegativeImbalance(amount)
        }
    }

    impl<T: Config<I>, I: 'static> TryDrop for PositiveImbalance<T, I> {
        fn try_drop(self) -> result::Result<(), Self> {
            self.drop_zero()
        }
    }

    impl<T: Config<I>, I: 'static> Default for PositiveImbalance<T, I> {
        fn default() -> Self {
            Self::zero()
        }
    }

    impl<T: Config<I>, I: 'static> Imbalance<T::Balance> for PositiveImbalance<T, I> {
        type Opposite = NegativeImbalance<T, I>;

        fn zero() -> Self {
            Self(Zero::zero())
        }
        fn drop_zero(self) -> result::Result<(), Self> {
            if self.0.is_zero() {
                Ok(())
            } else {
                Err(self)
            }
        }
        fn split(self, amount: T::Balance) -> (Self, Self) {
            let first = self.0.min(amount);
            let second = self.0 - first;

            mem::forget(self);
            (Self(first), Self(second))
        }
        fn merge(mut self, other: Self) -> Self {
            self.0 = self.0.saturating_add(other.0);
            mem::forget(other);

            self
        }
        fn subsume(&mut self, other: Self) {
            self.0 = self.0.saturating_add(other.0);
            mem::forget(other);
        }
        fn offset(self, other: Self::Opposite) -> SameOrOther<Self, Self::Opposite> {
            let (a, b) = (self.0, other.0);
            mem::forget((self, other));

            if a > b {
                SameOrOther::Same(Self(a - b))
            } else if b > a {
                SameOrOther::Other(NegativeImbalance::new(b - a))
            } else {
                SameOrOther::None
            }
        }
        fn peek(&self) -> T::Balance {
            self.0
        }
    }

    impl<T: Config<I>, I: 'static> TryDrop for NegativeImbalance<T, I> {
        fn try_drop(self) -> result::Result<(), Self> {
            self.drop_zero()
        }
    }

    impl<T: Config<I>, I: 'static> Default for NegativeImbalance<T, I> {
        fn default() -> Self {
            Self::zero()
        }
    }

    impl<T: Config<I>, I: 'static> Imbalance<T::Balance> for NegativeImbalance<T, I> {
        type Opposite = PositiveImbalance<T, I>;

        fn zero() -> Self {
            Self(Zero::zero())
        }
        fn drop_zero(self) -> result::Result<(), Self> {
            if self.0.is_zero() {
                Ok(())
            } else {
                Err(self)
            }
        }
        fn split(self, amount: T::Balance) -> (Self, Self) {
            let first = self.0.min(amount);
            let second = self.0 - first;

            mem::forget(self);
            (Self(first), Self(second))
        }
        fn merge(mut self, other: Self) -> Self {
            self.0 = self.0.saturating_add(other.0);
            mem::forget(other);

            self
        }
        fn subsume(&mut self, other: Self) {
            self.0 = self.0.saturating_add(other.0);
            mem::forget(other);
        }
        fn offset(self, other: Self::Opposite) -> SameOrOther<Self, Self::Opposite> {
            let (a, b) = (self.0, other.0);
            mem::forget((self, other));

            if a > b {
                SameOrOther::Same(Self(a - b))
            } else if b > a {
                SameOrOther::Other(PositiveImbalance::new(b - a))
            } else {
                SameOrOther::None
            }
        }
        fn peek(&self) -> T::Balance {
            self.0
        }
    }

    impl<T: Config<I>, I: 'static> Drop for PositiveImbalance<T, I> {
        /// Basic drop handler will just square up the total issuance.
        fn drop(&mut self) {
            <super::TotalIssuance<T, I>>::mutate(|v| *v = v.saturating_add(self.0));
        }
    }

    impl<T: Config<I>, I: 'static> Drop for NegativeImbalance<T, I> {
        /// Basic drop handler will just square up the total issuance.
        fn drop(&mut self) {
            <super::TotalIssuance<T, I>>::mutate(|v| *v = v.saturating_sub(self.0));
        }
    }
}

impl<T: Config<I>, I: 'static> Currency<T::AccountId> for Pallet<T, I>
where
    T::Balance: MaybeSerializeDeserialize + Debug,
{
    type Balance = T::Balance;
    type PositiveImbalance = PositiveImbalance<T, I>;
    type NegativeImbalance = NegativeImbalance<T, I>;

    fn total_balance(who: &T::AccountId) -> Self::Balance {
        Self::account(who).total()
    }

    // Check if `value` amount of free balance can be slashed from `who`.
    fn can_slash(who: &T::AccountId, value: Self::Balance) -> bool {
        if value.is_zero() {
            return true
        }
        Self::free_balance(who) >= value
    }

    fn total_issuance() -> Self::Balance {
        <TotalIssuance<T, I>>::get()
    }

    fn minimum_balance() -> Self::Balance {
        T::ExistentialDeposit::get()
    }

    // Burn funds from the total issuance, returning a positive imbalance for the amount burned.
    // Is a no-op if amount to be burned is zero.
    fn burn(mut amount: Self::Balance) -> Self::PositiveImbalance {
        if amount.is_zero() {
            return PositiveImbalance::zero()
        }
        <TotalIssuance<T, I>>::mutate(|issued| {
            *issued = issued.checked_sub(&amount).unwrap_or_else(|| {
                amount = *issued;
                Zero::zero()
            });
        });
        PositiveImbalance::new(amount)
    }

    // Create new funds into the total issuance, returning a negative imbalance
    // for the amount issued.
    // Is a no-op if amount to be issued it zero.
    fn issue(mut amount: Self::Balance) -> Self::NegativeImbalance {
        if amount.is_zero() {
            return NegativeImbalance::zero()
        }
        <TotalIssuance<T, I>>::mutate(|issued| {
            *issued = issued.checked_add(&amount).unwrap_or_else(|| {
                amount = Self::Balance::max_value() - *issued;
                Self::Balance::max_value()
            })
        });
        NegativeImbalance::new(amount)
    }

    fn free_balance(who: &T::AccountId) -> Self::Balance {
        Self::account(who).free
    }

    // Ensure that an account can withdraw from their free balance given any existing withdrawal
    // restrictions like locks and vesting balance.
    // Is a no-op if amount to be withdrawn is zero.
    //
    // # <weight>
    // Despite iterating over a list of locks, they are limited by the number of
    // lock IDs, which means the number of runtime pallets that intend to use and create locks.
    // # </weight>
    fn ensure_can_withdraw(
        who: &T::AccountId,
        amount: T::Balance,
        reasons: WithdrawReasons,
        new_balance: T::Balance,
    ) -> DispatchResult {
        if amount.is_zero() {
            return Ok(())
        }
        let min_balance = Self::account(who).frozen(reasons.into());
        ensure!(new_balance >= min_balance, Error::<T, I>::LiquidityRestrictions);
        Ok(())
    }

    // Transfer some free balance from `transactor` to `dest`, respecting existence requirements.
    // Is a no-op if value to be transferred is zero or the `transactor` is the same as `dest`.
    fn transfer(
        transactor: &T::AccountId,
        dest: &T::AccountId,
        value: Self::Balance,
        existence_requirement: ExistenceRequirement,
    ) -> DispatchResult {
        if value.is_zero() || transactor == dest {
            return Ok(())
        }

        Self::try_mutate_account_with_dust(
            dest,
            |to_account, _| -> Result<DustCleaner<T, I>, DispatchError> {
                Self::try_mutate_account_with_dust(
                    transactor,
                    |from_account, _| -> DispatchResult {
                        from_account.free = from_account
                            .free
                            .checked_sub(&value)
                            .ok_or(Error::<T, I>::InsufficientBalance)?;

                        // NOTE: total stake being stored in the same type means that this could
                        // never overflow but better to be safe than sorry.
                        to_account.free =
                            to_account.free.checked_add(&value).ok_or(ArithmeticError::Overflow)?;

                        let ed = T::ExistentialDeposit::get();
                        ensure!(to_account.total() >= ed, Error::<T, I>::ExistentialDeposit);

                        Self::ensure_can_withdraw(
                            transactor,
                            value,
                            WithdrawReasons::TRANSFER,
                            from_account.free,
                        )
                        .map_err(|_| Error::<T, I>::LiquidityRestrictions)?;

                        // TODO: This is over-conservative. There may now be other providers, and
                        // this pallet may not even be a provider.
                        let allow_death = existence_requirement == ExistenceRequirement::AllowDeath;
                        let allow_death =
                            allow_death && system::Pallet::<T>::can_dec_provider(transactor);
                        ensure!(
                            allow_death || from_account.total() >= ed,
                            Error::<T, I>::KeepAlive
                        );

                        Ok(())
                    },
                )
                .map(|(_, maybe_dust_cleaner)| maybe_dust_cleaner)
            },
        )?;

        // Emit transfer event.
        Self::deposit_event(Event::Transfer {
            from: transactor.clone(),
            to: dest.clone(),
            amount: value,
        });

        Ok(())
    }

    /// Slash a target account `who`, returning the negative imbalance created and any left over
    /// amount that could not be slashed.
    ///
    /// Is a no-op if `value` to be slashed is zero or the account does not exist.
    ///
    /// NOTE: `slash()` prefers free balance, but assumes that reserve balance can be drawn
    /// from in extreme circumstances. `can_slash()` should be used prior to `slash()` to avoid
    /// having to draw from reserved funds, however we err on the side of punishment if things are
    /// inconsistent or `can_slash` wasn't used appropriately.
    fn slash(who: &T::AccountId, value: Self::Balance) -> (Self::NegativeImbalance, Self::Balance) {
        if value.is_zero() {
            return (NegativeImbalance::zero(), Zero::zero())
        }
        if Self::total_balance(who).is_zero() {
            return (NegativeImbalance::zero(), value)
        }

        for attempt in 0..2 {
            match Self::try_mutate_account(
                who,
                |account,
                 _is_new|
                 -> Result<(Self::NegativeImbalance, Self::Balance), DispatchError> {
                    // Best value is the most amount we can slash following liveness rules.
                    let best_value = match attempt {
                        // First attempt we try to slash the full amount, and see if liveness issues
                        // happen.
                        0 => value,
                        // If acting as a critical provider (i.e. first attempt failed), then slash
                        // as much as possible while leaving at least at ED.
                        _ => value.min(
                            (account.free + account.reserved)
                                .saturating_sub(T::ExistentialDeposit::get()),
                        ),
                    };

                    let free_slash = cmp::min(account.free, best_value);
                    account.free -= free_slash; // Safe because of above check
                    let remaining_slash = best_value - free_slash; // Safe because of above check

                    if !remaining_slash.is_zero() {
                        // If we have remaining slash, take it from reserved balance.
                        let reserved_slash = cmp::min(account.reserved, remaining_slash);
                        account.reserved -= reserved_slash; // Safe because of above check
                        Ok((
                            NegativeImbalance::new(free_slash + reserved_slash),
                            value - free_slash - reserved_slash, /* Safe because value is gt or
                                                                  * eq total slashed */
                        ))
                    } else {
                        // Else we are done!
                        Ok((
                            NegativeImbalance::new(free_slash),
                            value - free_slash, // Safe because value is gt or eq to total slashed
                        ))
                    }
                },
            ) {
                Ok((imbalance, not_slashed)) => {
                    Self::deposit_event(Event::Slashed {
                        who: who.clone(),
                        amount: value.saturating_sub(not_slashed),
                    });
                    return (imbalance, not_slashed)
                },
                Err(_) => (),
            }
        }

        // Should never get here. But we'll be defensive anyway.
        (Self::NegativeImbalance::zero(), value)
    }

    /// Deposit some `value` into the free balance of an existing target account `who`.
    ///
    /// Is a no-op if the `value` to be deposited is zero.
    fn deposit_into_existing(
        who: &T::AccountId,
        value: Self::Balance,
    ) -> Result<Self::PositiveImbalance, DispatchError> {
        if value.is_zero() {
            return Ok(PositiveImbalance::zero())
        }

        Self::try_mutate_account(
            who,
            |account, is_new| -> Result<Self::PositiveImbalance, DispatchError> {
                ensure!(!is_new, Error::<T, I>::DeadAccount);
                account.free = account.free.checked_add(&value).ok_or(ArithmeticError::Overflow)?;
                Self::deposit_event(Event::Deposit { who: who.clone(), amount: value });
                Ok(PositiveImbalance::new(value))
            },
        )
    }

    /// Deposit some `value` into the free balance of `who`, possibly creating a new account.
    ///
    /// This function is a no-op if:
    /// - the `value` to be deposited is zero; or
    /// - the `value` to be deposited is less than the required ED and the account does not yet
    ///   exist; or
    /// - the deposit would necessitate the account to exist and there are no provider references;
    ///   or
    /// - `value` is so large it would cause the balance of `who` to overflow.
    fn deposit_creating(who: &T::AccountId, value: Self::Balance) -> Self::PositiveImbalance {
        if value.is_zero() {
            return Self::PositiveImbalance::zero()
        }

        Self::try_mutate_account(
            who,
            |account, is_new| -> Result<Self::PositiveImbalance, DispatchError> {
                let ed = T::ExistentialDeposit::get();
                ensure!(value >= ed || !is_new, Error::<T, I>::ExistentialDeposit);

                // defensive only: overflow should never happen, however in case it does, then this
                // operation is a no-op.
                account.free = match account.free.checked_add(&value) {
                    Some(x) => x,
                    None => return Ok(Self::PositiveImbalance::zero()),
                };

                Self::deposit_event(Event::Deposit { who: who.clone(), amount: value });
                Ok(PositiveImbalance::new(value))
            },
        )
        .unwrap_or_else(|_| Self::PositiveImbalance::zero())
    }

    /// Withdraw some free balance from an account, respecting existence requirements.
    ///
    /// Is a no-op if value to be withdrawn is zero.
    fn withdraw(
        who: &T::AccountId,
        value: Self::Balance,
        reasons: WithdrawReasons,
        liveness: ExistenceRequirement,
    ) -> result::Result<Self::NegativeImbalance, DispatchError> {
        if value.is_zero() {
            return Ok(NegativeImbalance::zero())
        }

        Self::try_mutate_account(
            who,
            |account, _| -> Result<Self::NegativeImbalance, DispatchError> {
                let new_free_account =
                    account.free.checked_sub(&value).ok_or(Error::<T, I>::InsufficientBalance)?;

                // bail if we need to keep the account alive and this would kill it.
                let ed = T::ExistentialDeposit::get();
                let would_be_dead = new_free_account + account.reserved < ed;
                let would_kill = would_be_dead && account.free + account.reserved >= ed;
                ensure!(liveness == AllowDeath || !would_kill, Error::<T, I>::KeepAlive);

                Self::ensure_can_withdraw(who, value, reasons, new_free_account)?;

                account.free = new_free_account;

                Self::deposit_event(Event::Withdraw { who: who.clone(), amount: value });
                Ok(NegativeImbalance::new(value))
            },
        )
    }

    /// Force the new free balance of a target account `who` to some new value `balance`.
    fn make_free_balance_be(
        who: &T::AccountId,
        value: Self::Balance,
    ) -> SignedImbalance<Self::Balance, Self::PositiveImbalance> {
        Self::try_mutate_account(
            who,
            |account,
             is_new|
             -> Result<SignedImbalance<Self::Balance, Self::PositiveImbalance>, DispatchError> {
                let ed = T::ExistentialDeposit::get();
                let total = value.saturating_add(account.reserved);
                // If we're attempting to set an existing account to less than ED, then
                // bypass the entire operation. It's a no-op if you follow it through, but
                // since this is an instance where we might account for a negative imbalance
                // (in the dust cleaner of set_account) before we account for its actual
                // equal and opposite cause (returned as an Imbalance), then in the
                // instance that there's no other accounts on the system at all, we might
                // underflow the issuance and our arithmetic will be off.
                ensure!(total >= ed || !is_new, Error::<T, I>::ExistentialDeposit);

                let imbalance = if account.free <= value {
                    SignedImbalance::Positive(PositiveImbalance::new(value - account.free))
                } else {
                    SignedImbalance::Negative(NegativeImbalance::new(account.free - value))
                };
                account.free = value;
                Self::deposit_event(Event::BalanceSet {
                    who: who.clone(),
                    free: account.free,
                    reserved: account.reserved,
                });
                Ok(imbalance)
            },
        )
        .unwrap_or_else(|_| SignedImbalance::Positive(Self::PositiveImbalance::zero()))
    }
}

impl<T: Config<I>, I: 'static> ReservableCurrency<T::AccountId> for Pallet<T, I>
where
    T::Balance: MaybeSerializeDeserialize + Debug,
{
    /// Check if `who` can reserve `value` from their free balance.
    ///
    /// Always `true` if value to be reserved is zero.
    fn can_reserve(who: &T::AccountId, value: Self::Balance) -> bool {
        if value.is_zero() {
            return true
        }
        Self::account(who).free.checked_sub(&value).map_or(false, |new_balance| {
            Self::ensure_can_withdraw(who, value, WithdrawReasons::RESERVE, new_balance).is_ok()
        })
    }

    fn reserved_balance(who: &T::AccountId) -> Self::Balance {
        Self::account(who).reserved
    }

    /// Move `value` from the free balance from `who` to their reserved balance.
    ///
    /// Is a no-op if value to be reserved is zero.
    fn reserve(who: &T::AccountId, value: Self::Balance) -> DispatchResult {
        if value.is_zero() {
            return Ok(())
        }

        Self::try_mutate_account(who, |account, _| -> DispatchResult {
            account.free =
                account.free.checked_sub(&value).ok_or(Error::<T, I>::InsufficientBalance)?;
            account.reserved =
                account.reserved.checked_add(&value).ok_or(ArithmeticError::Overflow)?;
            Self::ensure_can_withdraw(&who, value, WithdrawReasons::RESERVE, account.free)
        })?;

        Self::deposit_event(Event::Reserved { who: who.clone(), amount: value });
        Ok(())
    }

    /// Unreserve some funds, returning any amount that was unable to be unreserved.
    ///
    /// Is a no-op if the value to be unreserved is zero or the account does not exist.
    fn unreserve(who: &T::AccountId, value: Self::Balance) -> Self::Balance {
        if value.is_zero() {
            return Zero::zero()
        }
        if Self::total_balance(who).is_zero() {
            return value
        }

        let actual = match Self::mutate_account(who, |account| {
            let actual = cmp::min(account.reserved, value);
            account.reserved -= actual;
            // defensive only: this can never fail since total issuance which is at least
            // free+reserved fits into the same data type.
            account.free = account.free.defensive_saturating_add(actual);
            actual
        }) {
            Ok(x) => x,
            Err(_) => {
                // This should never happen since we don't alter the total amount in the account.
                // If it ever does, then we should fail gracefully though, indicating that nothing
                // could be done.
                return value
            },
        };

        Self::deposit_event(Event::Unreserved { who: who.clone(), amount: actual });
        value - actual
    }

    /// Slash from reserved balance, returning the negative imbalance created,
    /// and any amount that was unable to be slashed.
    ///
    /// Is a no-op if the value to be slashed is zero or the account does not exist.
    fn slash_reserved(
        who: &T::AccountId,
        value: Self::Balance,
    ) -> (Self::NegativeImbalance, Self::Balance) {
        if value.is_zero() {
            return (NegativeImbalance::zero(), Zero::zero())
        }
        if Self::total_balance(who).is_zero() {
            return (NegativeImbalance::zero(), value)
        }

        // NOTE: `mutate_account` may fail if it attempts to reduce the balance to the point that an
        //   account is attempted to be illegally destroyed.

        for attempt in 0..2 {
            match Self::mutate_account(who, |account| {
                let best_value = match attempt {
                    0 => value,
                    // If acting as a critical provider (i.e. first attempt failed), then ensure
                    // slash leaves at least the ED.
                    _ => value.min(
                        (account.free + account.reserved)
                            .saturating_sub(T::ExistentialDeposit::get()),
                    ),
                };

                let actual = cmp::min(account.reserved, best_value);
                account.reserved -= actual;

                // underflow should never happen, but it if does, there's nothing to be done here.
                (NegativeImbalance::new(actual), value - actual)
            }) {
                Ok((imbalance, not_slashed)) => {
                    Self::deposit_event(Event::Slashed {
                        who: who.clone(),
                        amount: value.saturating_sub(not_slashed),
                    });
                    return (imbalance, not_slashed)
                },
                Err(_) => (),
            }
        }
        // Should never get here as we ensure that ED is left in the second attempt.
        // In case we do, though, then we fail gracefully.
        (Self::NegativeImbalance::zero(), value)
    }

    /// Move the reserved balance of one account into the balance of another, according to `status`.
    ///
    /// Is a no-op if:
    /// - the value to be moved is zero; or
    /// - the `slashed` id equal to `beneficiary` and the `status` is `Reserved`.
    fn repatriate_reserved(
        slashed: &T::AccountId,
        beneficiary: &T::AccountId,
        value: Self::Balance,
        status: Status,
    ) -> Result<Self::Balance, DispatchError> {
        let actual = Self::do_transfer_reserved(slashed, beneficiary, value, true, status)?;
        Ok(value.saturating_sub(actual))
    }
}

impl<T: Config<I>, I: 'static> NamedReservableCurrency<T::AccountId> for Pallet<T, I>
where
    T::Balance: MaybeSerializeDeserialize + Debug,
{
    type ReserveIdentifier = T::ReserveIdentifier;

    fn reserved_balance_named(id: &Self::ReserveIdentifier, who: &T::AccountId) -> Self::Balance {
        let reserves = Self::reserves(who);
        reserves
            .binary_search_by_key(id, |data| data.id)
            .map(|index| reserves[index].amount)
            .unwrap_or_default()
    }

    /// Move `value` from the free balance from `who` to a named reserve balance.
    ///
    /// Is a no-op if value to be reserved is zero.
    fn reserve_named(
        id: &Self::ReserveIdentifier,
        who: &T::AccountId,
        value: Self::Balance,
    ) -> DispatchResult {
        if value.is_zero() {
            return Ok(())
        }

        Reserves::<T, I>::try_mutate(who, |reserves| -> DispatchResult {
            match reserves.binary_search_by_key(id, |data| data.id) {
                Ok(index) => {
                    // this add can't overflow but just to be defensive.
                    reserves[index].amount = reserves[index].amount.defensive_saturating_add(value);
                },
                Err(index) => {
                    reserves
                        .try_insert(index, ReserveData { id: *id, amount: value })
                        .map_err(|_| Error::<T, I>::TooManyReserves)?;
                },
            };
            <Self as ReservableCurrency<_>>::reserve(who, value)?;
            Ok(())
        })
    }

    /// Unreserve some funds, returning any amount that was unable to be unreserved.
    ///
    /// Is a no-op if the value to be unreserved is zero.
    fn unreserve_named(
        id: &Self::ReserveIdentifier,
        who: &T::AccountId,
        value: Self::Balance,
    ) -> Self::Balance {
        if value.is_zero() {
            return Zero::zero()
        }

        Reserves::<T, I>::mutate_exists(who, |maybe_reserves| -> Self::Balance {
            if let Some(reserves) = maybe_reserves.as_mut() {
                match reserves.binary_search_by_key(id, |data| data.id) {
                    Ok(index) => {
                        let to_change = cmp::min(reserves[index].amount, value);

                        let remain = <Self as ReservableCurrency<_>>::unreserve(who, to_change);

                        // remain should always be zero but just to be defensive here.
                        let actual = to_change.defensive_saturating_sub(remain);

                        // `actual <= to_change` and `to_change <= amount`; qed;
                        reserves[index].amount -= actual;

                        if reserves[index].amount.is_zero() {
                            if reserves.len() == 1 {
                                // no more named reserves
                                *maybe_reserves = None;
                            } else {
                                // remove this named reserve
                                reserves.remove(index);
                            }
                        }

                        value - actual
                    },
                    Err(_) => value,
                }
            } else {
                value
            }
        })
    }

    /// Slash from reserved balance, returning the negative imbalance created,
    /// and any amount that was unable to be slashed.
    ///
    /// Is a no-op if the value to be slashed is zero.
    fn slash_reserved_named(
        id: &Self::ReserveIdentifier,
        who: &T::AccountId,
        value: Self::Balance,
    ) -> (Self::NegativeImbalance, Self::Balance) {
        if value.is_zero() {
            return (NegativeImbalance::zero(), Zero::zero())
        }

        Reserves::<T, I>::mutate(who, |reserves| -> (Self::NegativeImbalance, Self::Balance) {
            match reserves.binary_search_by_key(id, |data| data.id) {
                Ok(index) => {
                    let to_change = cmp::min(reserves[index].amount, value);

                    let (imb, remain) =
                        <Self as ReservableCurrency<_>>::slash_reserved(who, to_change);

                    // remain should always be zero but just to be defensive here.
                    let actual = to_change.defensive_saturating_sub(remain);

                    // `actual <= to_change` and `to_change <= amount`; qed;
                    reserves[index].amount -= actual;

                    Self::deposit_event(Event::Slashed { who: who.clone(), amount: actual });
                    (imb, value - actual)
                },
                Err(_) => (NegativeImbalance::zero(), value),
            }
        })
    }

    /// Move the reserved balance of one account into the balance of another, according to `status`.
    /// If `status` is `Reserved`, the balance will be reserved with given `id`.
    ///
    /// Is a no-op if:
    /// - the value to be moved is zero; or
    /// - the `slashed` id equal to `beneficiary` and the `status` is `Reserved`.
    fn repatriate_reserved_named(
        id: &Self::ReserveIdentifier,
        slashed: &T::AccountId,
        beneficiary: &T::AccountId,
        value: Self::Balance,
        status: Status,
    ) -> Result<Self::Balance, DispatchError> {
        if value.is_zero() {
            return Ok(Zero::zero())
        }

        if slashed == beneficiary {
            return match status {
                Status::Free => Ok(Self::unreserve_named(id, slashed, value)),
                Status::Reserved =>
                    Ok(value.saturating_sub(Self::reserved_balance_named(id, slashed))),
            }
        }

        Reserves::<T, I>::try_mutate(slashed, |reserves| -> Result<Self::Balance, DispatchError> {
            match reserves.binary_search_by_key(id, |data| data.id) {
                Ok(index) => {
                    let to_change = cmp::min(reserves[index].amount, value);

                    let actual = if status == Status::Reserved {
                        // make it the reserved under same identifier
                        Reserves::<T, I>::try_mutate(
                            beneficiary,
                            |reserves| -> Result<T::Balance, DispatchError> {
                                match reserves.binary_search_by_key(id, |data| data.id) {
                                    Ok(index) => {
                                        let remain =
                                            <Self as ReservableCurrency<_>>::repatriate_reserved(
                                                slashed,
                                                beneficiary,
                                                to_change,
                                                status,
                                            )?;

                                        // remain should always be zero but just to be defensive
                                        // here.
                                        let actual = to_change.defensive_saturating_sub(remain);

                                        // this add can't overflow but just to be defensive.
                                        reserves[index].amount =
                                            reserves[index].amount.defensive_saturating_add(actual);

                                        Ok(actual)
                                    },
                                    Err(index) => {
                                        let remain =
                                            <Self as ReservableCurrency<_>>::repatriate_reserved(
                                                slashed,
                                                beneficiary,
                                                to_change,
                                                status,
                                            )?;

                                        // remain should always be zero but just to be defensive
                                        // here
                                        let actual = to_change.defensive_saturating_sub(remain);

                                        reserves
                                            .try_insert(
                                                index,
                                                ReserveData { id: *id, amount: actual },
                                            )
                                            .map_err(|_| Error::<T, I>::TooManyReserves)?;

                                        Ok(actual)
                                    },
                                }
                            },
                        )?
                    } else {
                        let remain = <Self as ReservableCurrency<_>>::repatriate_reserved(
                            slashed,
                            beneficiary,
                            to_change,
                            status,
                        )?;

                        // remain should always be zero but just to be defensive here
                        to_change.defensive_saturating_sub(remain)
                    };

                    // `actual <= to_change` and `to_change <= amount`; qed;
                    reserves[index].amount -= actual;

                    Ok(value - actual)
                },
                Err(_) => Ok(value),
            }
        })
    }
}

impl<T: Config<I>, I: 'static> LockableCurrency<T::AccountId> for Pallet<T, I>
where
    T::Balance: MaybeSerializeDeserialize + Debug,
{
    type Moment = T::BlockNumber;

    type MaxLocks = T::MaxLocks;

    // Set a lock on the balance of `who`.
    // Is a no-op if lock amount is zero or `reasons` `is_none()`.
    fn set_lock(
        id: LockIdentifier,
        who: &T::AccountId,
        amount: T::Balance,
        reasons: WithdrawReasons,
    ) {
        if amount.is_zero() || reasons.is_empty() {
            return
        }
        let mut new_lock = Some(BalanceLock { id, amount, reasons: reasons.into() });
        let mut locks = Self::locks(who)
            .into_iter()
            .filter_map(|l| if l.id == id { new_lock.take() } else { Some(l) })
            .collect::<Vec<_>>();
        if let Some(lock) = new_lock {
            locks.push(lock)
        }
        Self::update_locks(who, &locks[..]);
    }

    // Extend a lock on the balance of `who`.
    // Is a no-op if lock amount is zero or `reasons` `is_none()`.
    fn extend_lock(
        id: LockIdentifier,
        who: &T::AccountId,
        amount: T::Balance,
        reasons: WithdrawReasons,
    ) {
        if amount.is_zero() || reasons.is_empty() {
            return
        }
        let mut new_lock = Some(BalanceLock { id, amount, reasons: reasons.into() });
        let mut locks = Self::locks(who)
            .into_iter()
            .filter_map(|l| {
                if l.id == id {
                    new_lock.take().map(|nl| BalanceLock {
                        id: l.id,
                        amount: l.amount.max(nl.amount),
                        reasons: l.reasons | nl.reasons,
                    })
                } else {
                    Some(l)
                }
            })
            .collect::<Vec<_>>();
        if let Some(lock) = new_lock {
            locks.push(lock)
        }
        Self::update_locks(who, &locks[..]);
    }

    fn remove_lock(id: LockIdentifier, who: &T::AccountId) {
        let mut locks = Self::locks(who);
        locks.retain(|l| l.id != id);
        Self::update_locks(who, &locks[..]);
    }
}

02

Generic Data types

타입 이름을 <> 안에 쓰고 인자를 써주면 됨

fn largest<T>(list: &[T]) -> T {}

여러 타입을 사용하고 싶으면 두 개 써주면 됨

struct Point<T, U> {
    x: T,
    y: U,
}

struct나 enum에 메소드를 선언하는 법

struct Point<X1, Y1> {
    x: X1,
    y: Y1,
}

impl<X1, Y1> Point<X1, Y1> {
    fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

컴파일러가 알아서 실제 인스턴스로 바꿔주기 때문에 런타임에선 굉장히 빨라짐

Traits: Defining Shared Behavior

trait은 어떤 특정 타입이 가질 수 있고 다른 타입과 공유 가능한 기능이다. trait 선언하기

pub trait Summary {
    fn summarize(&self) -> String;
    fn summarize_default(&self) -> String {
        String::from("(Read more...)")
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

impl Summary for Tweet {} // default 사용할 때

이 trait을 구현하는 각 타입이 이 메소드의 바디를 구현해야 함 trait은 외부 타입에는 구현할 수 없음 orphan rule

pub fn notify(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

pub fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
} // 함수에 제네릭 사용하기


//여러 trait 바운드
pub fn notify(item: &(impl Summary + Display)) {}
pub fn notify<T: Summary + Display>(item: &T) {}


// trait 너무 많으면 where안에 쓰도록
fn some_function<T, U>(t: &T, u: &U) -> i32
    where T: Display + Clone,
          U: Clone + Debug
{

item은 Summary trait을 구현하는 어떤 타입이든지 가ㅡㅇ

// 해당 trait을 구현하는 타입으로 리턴
fn returns_summarizable() -> impl Summary {
    Tweet {
        username: String::from("horse_ebooks"),
        content: String::from(
            "of course, as you probably already know, people",
        ),
        reply: false,
        retweet: false,
    }
}

Validating References with Lifetimes

&i32        // a reference
&'a i32     // a reference with an explicit lifetime
&'a mut i32 // a mutable reference with an explicit lifetime

the returned reference will be valid as long as both the parameters are valid. This is the relationship between lifetimes of the parameters and the return value.

 fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

it means that the lifetime of the reference returned by the longest function is the same as the smaller of the lifetimes of the references passed in. These relationships are what we want Rust to use when analyzing this code.

we’re specifying that the borrow checker should reject any values that don’t adhere to these constraints. Note that the longest function doesn’t need to know exactly how long x and y will live, only that some scope can be substituted for 'a that will satisfy this signature.

struct ImportantExcerpt<'a> {
    part: &'a str,
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");
    let i = ImportantExcerpt {
        part: first_sentence,
    };
}

lifetime elision rules : if your code fits these cases, you don’t need to write the lifetimes explicitly

Lifetimes on function or method parameters are called input lifetimes, and lifetimes on return values are called output lifetimes.

The compiler uses three rules to figure out the lifetimes of the references when there aren’t explicit annotations. The first rule applies to input lifetimes, and the second and third rules apply to output lifetimes. If the compiler gets to the end of the three rules and there are still references for which it can’t figure out lifetimes, the compiler will stop with an error. These rules apply to fn definitions as well as impl blocks.

The first rule is that the compiler assigns a lifetime parameter to each parameter that’s a reference. In other words, a function with one parameter gets one lifetime parameter: fn foo<'a>(x: &'a i32); a function with two parameters gets two separate lifetime parameters: fn foo<'a, 'b>(x: &'a i32, y: &'b i32); and so on.

The second rule is that, if there is exactly one input lifetime parameter, that lifetime is assigned to all output lifetime parameters: fn foo<'a>(x: &'a i32) -> &'a i32.

The third rule is that, if there are multiple input lifetime parameters, but one of them is &self or &mut self because this is a method, the lifetime of self is assigned to all output lifetime parameters. This third rule makes methods much nicer to read and write because fewer symbols are necessary.

모든 블록체인은 성공적으로 블록을 만들고 다음 블록으로 넘어가기 위해 네트워크의 모든 노드들이 메시지와 그 메시지들의 순서에 합의해야 함 각 블록은 특정 시점의 데이터 상태를 나타내고 그 상태에 대한 노드들의 동의를 합의라고 함 합의에 도달하기 위해 여러 알고리즘들이 사용됨:

• PoW : 검증자 노드들이 블록을 체인에 추가하기 위해 하는 연산 작업에 의해
• PoS : 암호화폐를 네트워크에 스테이킹한 양에 기반해 블록을 추가할 수 있는 검증자들을 선정
• PoA : 검증자로 활동하는 인증된 계정들이 합의. 인증된 계정과 연관된 노드들이 블록을 만들 권한 가짐

Substrate 노드 템플릿은 PoA를 사용하고 이를 authority round 또는 Aura합의라고 부름 Aura 합의 프로토콜은 round-robin 방식으로 블록을 생성하는 권한 있는 계정 리스트-authorities-에서 순환하도록 블록 생성을 제한함 *round robin : 프로세스들 사이에 우선순위를 두지 않고, 순서대로 할당

이 튜토리얼에서 실제로 이 합의 모델이 어떻게 작동하는지 알아볼 텐데, 먼저 노드 템플릿에 미리 정의된 계정들을 사용한 다음 인증된 집합에 새로운 권한을 추가해볼 것임

시작하기 전에

• Rust와 Rust toolchain 설치
• 튜토리얼 1번 완료하고 Substrate node template 다운
• CLI로 개발하는 것에 익숙하다고 가정
• 블록체인과 스마트 컨트랙트 플랫폼에 익숙하다고 가정

튜토리얼 목표

• 미리 정의된 계정들을 사용해서 peer 블록체인 노드 시작하기
• 네트워크 권한으로 사용하기 위해 key pair 생성하기
• 커스텀 체인 명세 파일 만들기
• private이면서 두 개의 노드를 갖는 블록체인 시작하기

미리 정의된 계정들로 블록체인 시작

private Substrate 네트워크를 시작하기 위해 key를 생성하기 전,local이라 불리는 미리 정의된 네트워크 명세를 사용해서 근본 원리를 배우고 미리 정의된 사용자 계정으로 실행해볼 수 있음

여기에서는 하나의 로컬 컴퓨터에서 alice 와 bob이라는 미리 정의된 계정들을 사용해서 두 개의 Substrate 노드들을 실행시킴으로써 private network를 시뮬레이션 할 것임

첫 번째 블록체인 노드 시작

1. 터미널 열기

2. Substrate node template을 컴파일한 루트 디렉토리로 가기

3. 다음 명령어를 실행해서 이전 체인 데이터 버리기

./target/release/node-template purge-chain --base-path /tmp/alice --chain local

다음 프롬프트가 뜨면

Are you sure to remove "/tmp/alice/chains/local_testnet/db"? [y/N]:

4. y 입력

새 네트워크 시작할 땐 이전 체인 데이터 항상 지워야 함

5. 다음 명령어를 실행해서 Alice 계정으로 로컬 블록체인 네트워크 시작 ```bash ./target/release/node-template \

--base-path /tmp/alice
--chain local
--alice
--port 30333
--ws-port 9945
--rpc-port 9933
--node-key 0000000000000000000000000000000000000000000000000000000000000001
--telemetry-url "wss://telemetry.polkadot.io/submit/ 0"
--validator

> **CLI 옵션 알아보기**
- `--base-path` : 이 체인과 관련된 모든 데이터를 저장하는 디렉토리
- `--chain local`    : 사용할 체인 명세. 유효한 미리 정의된 체인 명세는  `local`, `development`, `staging`을 포함
- `--alice` : 노드의 keystore에 `Alice` 계정의 미리 정의된 키들을 추가. 이 설정으로 `Alice` 계정이 블록 생성과 finalization에 사용됨
- `--port 30333` : peer-to-peer (`p2p`) 트래픽을 수신할 포트 번호. 네으퉈크 시뮬레이션을 위해 같은 물리적 컴퓨터에서 두 개의 노드를 실행시키기 때문에, 적어도 하나의 계정에서는 다른 포트 번호를 명시해줘야 함
- `--ws-port 9945` : WebSocket 트래픽을 수신하기 위한 포트번호. 디폴트는  `9944`지만 이 튜토리얼에서는 `9945` 사용.
- `--rpc-port 9933`    : RPC 트래픽 수신하기 위한 포트번호 명시. 디폴트는 `9933`.
- `--node-key <key>` : `libp2p` 네트워킹에 사용할 Ed25519 비밀 키 명시. 개발과 테스트를 위해서만 이 옵션 사용해야 함
- `--telemetry-url`    : 원격 측정 데이터를 어디로 보낼지 명시. 이 튜토리얼에서는 Parity가 누구나 사용할 수 있도록 호스팅하는 서버에 보낼 것
- `--validator`    : 이 노드가 네트워크에서 블록 생성과 finalization에 참여한다는 것 명시
`./target/release/node-template --help` 명령어로 더 알아볼 수 있음

> **표시되는 노드 메시지 리뷰**
노드가 성공적으로 시작했다면, 터미널에 네트워크 작동을 설명하는 메시지가 표시될 것
- `🔨 Initializing Genesis block/state (state: 0xea47…9ba8, header-hash: 0x9d07…7cce)` : 노드가 사용하는 **genesis block**을 식별. 다음 노드를 시작하면, 이 값이 동일한 것을 확인할 수 있음

- `🏷 Local node identity is: 12D3KooWEyoppNCUx8Yx66oV9fJnriXwCcXwDDUA2kj6vnc6iDEp` : 유일하게 이 노드를 식별하는 문자열. 이 문자열은 `alice` 계정을 사용해서 노드를 시작할 때 사용된 `--node-key`에 의해 결정됨. 두 번째 노드를 시작할 때 이 노드를 연결하기 위해 이 문자열을 사용할 것

- `2021-03-10 17:34:37 💤 Idle (0 peers), best: #0 (0x9d07…7cce), finalized #0 (0x9d07…7cce), ⬇ 0 ⬆ 0` : 네트워크에 다른 노드가 없고 어떤 블록도 생성되고 있지 않음을 나타냄. 블록 생성을 시작하기 전에 반드시 다른 노드가 참여해야만 함

## 노드 정보 보기 위해 프론트엔드 추가

Polkadot-JS application을 사용해 노드 동작을 보기 위해:

1. 웹브라우저 열기

2. Polkadot-JS Explorer로 가기

Polkadot-JS Explorer 링크는 로컬 노드에 연결하기 위해 `rpc` URL 인자를 사용

> 어떤 브라우저들은 로컬 노드에 연결하는 것을 막는 광고 차단 기능이 있음. 만약 로컬 노드에 연결하는 것에 문제가 있다면, 광고 차단이 활성화되어있는지 확인하고 비활성화 하거나 다른 브라우저에서 실행해보길!

1. 상단 왼쪽 코너에 있는 네트워크 아이콘 클릭
2. 사용가능한 네트워크 리스트에서 **DEVELOPMENT** 클릭
3. 커스텀 엔드포인트가 로컬호스트와 WebSocket 트래픽 수신을 위해 명시한 포트번호로 설정되어 있는지 확인. 다른 네트워크, 노드, 엔드포인트에 연결할 때도 하나의 Polkadot-JS application을 사용할 수 있음

## 블록체인 네트워크에 두 번째 노드 추가

이제 `alice` 계정 키를 사용해서 시작한 노드가 작동하니까, `bob` 계정을 사용해 네트워크에 또다른 노드를 추가할 수 있음
이미 돌아가는 네트워크에 참여하기 때문에, 새로운 노드가 참여할 때 이 네트워크를 식별하는 데 돌아가는 노드를 사용할 수 있음. 

돌아가는 블록체인에 노드를 추가하기 위해서:

1. **새** 터미널 열기

2. Substrate node template을 컴파일한 루트 디렉토리로 가기

3. 다음 커맨드로 이전 체인 데이터를 지우기
```bash
./target/release/node-template purge-chain --base-path /tmp/bob --chain local -y

4. 다음 커맨드를 실행해서 bob계정을 사용해서 두 번째 로컬 블록체인 노드를 시작

./target/release/node-template \
--base-path /tmp/bob \
--chain local \
--bob \
--port 30334 \
--ws-port 9946 \
--rpc-port 9934 \
--telemetry-url "wss://telemetry.polkadot.io/submit/ 0" \
--validator \
--bootnodes /ip4/127.0.0.1/tcp/30333/p2p/12D3KooWEyoppNCUx8Yx66oV9fJnriXwCcXwDDUA2kj6vnc6iDEp

이 커맨드와 앨리스 시작할 때 썼던 커맨드 사이의 차이점에 주목

• 두 개의 노드가 하나의 같은 컴퓨터에서 돌아가기 때문에,--base-path, --port, --ws-port, --rpc-port 옵션에 다른 값을 명시해줘야 함

---bootnodes 옵션을 사용해 alice에 의해 시작된 노드를 하나의 부트 노드로 명시

--bootnodes 옵션은

• ip4 : 이 노드의 IP주소가 IPv4형식
• 127.0.0.1 : 돌아갈 노드의 IP 주소 명시(지금은 localhost)
• tcp : peer-to-peer 소통을 위한 프로토콜
• 30333 : peer-to-peer 소통을 위한 포트번호
• 12D3KooWEyoppNCUx8Yx66oV9fJnriXwCcXwDDUA2kj6vnc6iDEp : 이 네트워크와 소통하기 위해 돌아가고 있는 노드를 식별함. 이 경우 alice 계정으로 시작한 노드의 식별자임

블록들이 생성되고 finalized되는 것 검증

After you start the second node, the nodes should connect to each other as peers and start producing blocks.

블록들이 finalized 되고 있는지 검증하기 위해:

1. 첫번째 노드 터미널에 다음같은 줄이 뜨는지 확인:

2021-03-10 17:47:32  🔍 Discovered new external address for our node: /ip4/127.0.0.1/tcp/30333/p2p/12D3KooWEyoppNCUx8Yx66oV9fJnriXwCcXwDDUA2kj6vnc6iDEp
2021-03-10 17:47:32  🔍 Discovered new external address for our node: /ip4/<your computer's LAN IP>/tcp/30333/p2p/12D3KooWEyoppNCUx8Yx66oV9fJnriXwCcXwDDUA2kj6vnc6iDEp
2021-03-10 17:47:33  💤 Idle (1 peers), best: #0 (0x9d07…7cce), finalized #0 (0x9d07…7cce), ⬇ 1.0kiB/s ⬆ 1.0kiB/s
2021-03-10 17:47:36  🙌 Starting consensus session on top of parent 0x9d07d1757a9ca248e58141ce52a11fca37f71007dec16650b87a853f0d4c7cce
2021-03-10 17:47:36  🎁 Prepared block for proposing at 1 [hash: 0x727826a5e6fba9a13af11422d4677b5f0743cc733c382232328e69fd307d1d2f; parent_hash: 0x9d07…7cce; extrinsics (1): [0x768a…a9e2]]
2021-03-10 17:47:36  🔖 Pre-sealed block for proposal at 1. Hash now 0x4841d8b2e62483fa4702b3ddcd1b603803842374dcdc1e9533ad407708b33dd8, previously 0x727826a5e6fba9a13af11422d4677b5f0743cc733c382232328e69fd307d1d2f.
2021-03-10 17:47:36  ✨ Imported #1 (0x4841…3dd8)
2021-03-10 17:47:36  ✨ Imported #1 (0xb241…2ae8)
2021-03-10 17:47:38  💤 Idle (1 peers), best: #1 (0x4841…3dd8), finalized #0 (0x9d07…7cce), ⬇ 0.8kiB/s ⬆ 0.8kiB/s
2021-03-10 17:47:42  ♻️  Reorg on #1,0x4841…3dd8 to #2,0x8b6a…dce6, common ancestor #0,0x9d07…7cce
2021-03-10 17:47:42  ✨ Imported #2 (0x8b6a…dce6)
2021-03-10 17:47:43  💤 Idle (1 peers), best: #2 (0x8b6a…dce6), finalized #0 (0x9d07…7cce), ⬇ 0.8kiB/s ⬆ 0.7kiB/s
2021-03-10 17:47:48  🙌 Starting consensus session on top of parent 0x8b6a3ab2fe9891b1af008ea0d92dae9bc84cfa5578231e81066d47928822dce6
2021-03-10 17:47:48  🎁 Prepared block for proposing at 3 [hash: 0xb887aef2097eff5869e38ccec0302bce372ad05ac2cdf9cc4725c38ec071fb7a; parent_hash: 0x8b6a…dce6; extrinsics (1): [0x82ac…2f20]]
2021-03-10 17:47:48  🔖 Pre-sealed block for proposal at 3. Hash now 0x34d608dd8be6b82bef4a7aaae1ec80930a5c4b8cf9bdc99013410e91544f3a2a, previously 0xb887aef2097eff5869e38ccec0302bce372ad05ac2cdf9cc4725c38ec071fb7a.
2021-03-10 17:47:48  ✨ Imported #3 (0x34d6…3a2a)
2021-03-10 17:47:48  💤 Idle (1 peers), best: #3 (0x34d6…3a2a), finalized #0 (0x9d07…7cce), ⬇ 0.7kiB/s ⬆ 0.8kiB/s
2021-03-10 17:47:53  💤 Idle (1 peers), best: #3 (0x34d6…3a2a), finalized #1 (0xb241…2ae8), ⬇ 0.6kiB/s ⬆ 0.7kiB/s
2021-03-10 17:47:54  ✨ Imported #4 (0x2b8a…fdc4)
2021-03-10 17:47:58  💤 Idle (1 peers), best: #4 (0x2b8a…fdc4), finalized #2 (0x8b6a…dce6), ⬇ 0.7kiB/s ⬆ 0.6kiB/s

2. 두 번째 노드를 시작한 터미널에서도 비슷한 출력값이 나오는지 확인

3. Polkadot-JS Explorer를 열고 네트워크가 블록 만들고 finalize 하는지 확인

4. Control-c 눌러서 두 노드 다 멈추기

나만의 key 만들기

Key 생성 옵션

node-template 서브커맨드인 Subkey 를 사용해서 키 쌍을 만들거나 다른 키 생성 유틸리티를 사용할 수도 있음 여기에선 Substrate node template과 key 서브 커맨드를 사용해서 로컬에 키를 생성하는 방법을 다룰 것

노드 템플릿 사용해서 로컬 키 생성

프로덕션 블록체인에서는 키를 만들 때 한 번도 인터넷에 연결된 적이 없는 분리된 컴퓨터를 사용해야 하고, 최소한 자신이 컨트롤할 수 없는 퍼블릭 또는 프라이빅 블록체인에서 사용할 키를 생성하기 전엔 인터넷에 연결하지 말아야 함

근데 여기선 노드 템플릿의 key 서브커맨드를 사용해서 로컬에 랜덤 키를 생성할 거라 인터넷에 연결되어 있어도 됨

노드 템플릿으로 키 생성하기 위해:

1. 터미널 열기

2. Substrate node template 컴파일한 루트 디렉토리로 가기

3. 다음 커맨드 실행해서 랜덤 비밀 phrase와 키 생성

./target/release/node-template key generate --scheme Sr25519 --password-interactive

4. 만든 키에 대한 비밀번호 입력

키를 생성하고 다음과 비슷한 출력값을 보여줘야 함

Secret phrase:  pig giraffe ceiling enter weird liar orange decline behind total despair fly
Secret seed:       0x0087016ebbdcf03d1b7b2ad9a958e14a43f2351cd42f2f0a973771b90fb0112f
Public key (hex):  0x1a4cc824f6585859851f818e71ac63cf6fdc81018189809814677b2a4699cf45
Account ID:        0x1a4cc824f6585859851f818e71ac63cf6fdc81018189809814677b2a4699cf45
Public key (SS58): 5CfBuoHDvZ4fd8jkLQicNL8tgjnK8pVG9AiuJrsNrRAx6CNW
SS58 Address:      5CfBuoHDvZ4fd8jkLQicNL8tgjnK8pVG9AiuJrsNrRAx6CNW

aura를 사용해 블록들을 생성하는 한 노드에 대한 Sr25519 키를 만든 것임. 위에서 계정에 대한 Sr25519 공개 키는

5CfBuoHDvZ4fd8jkLQicNL8tgjnK8pVG9AiuJrsNrRAx6CNW임

5. Ed25519 서명 방법을 사용해서 키를 만들어내기 위해 방금 생성한 계정의 비밀 구문을 사용 다음과 같은 명령어 실행

./target/release/node-template key inspect --password-interactive --scheme Ed25519 "pig giraffe ceiling enter weird liar orange decline behind total despair fly"

5CuqCGfwqhjGzSqz5mnq36tMe651mU9Ji8xQ4JRuUTvPcjVN임

6. 키 만드는 데 썼던 비밀번호 입력 다음과 비슷한 출력값 보일 것임

   Secret phrase `pig giraffe ceiling enter weird liar orange decline behind total despair fly` is account:
   Secret seed:       0x0087016ebbdcf03d1b7b2ad9a958e14a43f2351cd42f2f0a973771b90fb0112f
   Public key (hex):  0x2577ba03f47cdbea161851d737e41200e471cd7a31a5c88242a527837efc1e7b
   Public key (SS58): 5CuqCGfwqhjGzSqz5mnq36tMe651mU9Ji8xQ4JRuUTvPcjVN
   Account ID:        0x2577ba03f47cdbea161851d737e41200e471cd7a31a5c88242a527837efc1e7b
   SS58 Address:      5CuqCGfwqhjGzSqz5mnq36tMe651mU9Ji8xQ4JRuUTvPcjVN

   이제 grandpa를 사용해 하나의 노드에 블록을 finalize하는 Ed25519 키를 생성한 것임. 여기서 Ed25519 공개 키는

5CuqCGfwqhjGzSqz5mnq36tMe651mU9Ji8xQ4JRuUTvPcjVN 임

두 번째 키 집합 생성

• 미리 생성된 계정을 쓰거나
• 방금 했던 거 한 번 더 해서 로컬에 두 개의 키 쌍 만들거나
• 자식 키 쌍을 만들거나
• 다른 참여자들을 모집해서 두 개의 계정을 사용할 수 있음

이 튜토리얼에서 사용된 두 번째 키 쌍은 다음과 같음:

• Sr25519: 5EJPj83tJuJtTVE2v7B9ehfM7jNT44CBFaPWicvBwYyUKBS6 for aura.
• Ed25519: 5FeJQsfmbbJLTH1pvehBxrZrT5kHvJFj84ZaY5LK7NU87gZS for grandpa.

커스텀 체인 명세 만들기

블록체인에 사용할 키들을 생성했다면, 방금 만든 키들을 사용한 커스텀 체인 스펙을 만들고 이 커스텀 체인 스펙을 검증자라 불리는 신뢰받는 네트워크 참여자들에게 공유할 준비를 다 한 것임

다른 사람들을 네트워크의 참여자로 포함하고 싶으면, 그들이 자신만의 키를 가지고 있어야 하고, 그렇다면 로컬 체인 스펙을 대체할 커스텀 체인 스펙을 만들 수 있음

존재하는 체인 명세 수정하기

이전에는 노드들을 블록체인에 추가할 때 --chain local 옵션으로 로컬 체인 명세를 사용했었음
완전히 새로운 체인 명세를 사용하기보단, 기존에 사용했던 것을 수정할 것임

1. 터미널 창 열기
2. Substrate node template 컴파일한 디렉토리로 가기
3. 다음 커맨드 실행해서 로컬 체인 스펙을 customSpec.json 이라는 이름으로 export하기

./target/release/node-template build-spec --disable-default-bootnode --chain local > customSpec.json

텍스트 에디터로 customSpec.json 파일을 열면, cargo build --release 커맨드를 사용해 만들었던 런타임을 위한 Wasm 바이너리를 다음 큰 블롭들을 포함한 여러 필드들을 볼 수 있을 것임 전체 파일을 보기보단, 처음과 마지막의 몇 줄에서만 바꿔야 하는 몇몇 필드들을 보겠음

4. 다음 커맨드로 customSpec.json 파일의 첫 번째 몇 필드들을 미리보기

   head customSpec.json

   출력값:

   {
   "name": "Local Testnet",
   "id": "local_testnet",
   "chainType": "Local",
   "bootNodes": [],
   "telemetryEndpoints": null,
   "protocolId": null,
   "properties": null,
   "consensusEngine": null,
   "codeSubstitutes": {},

5. 다음 커맨드로 customSpec.json 파일의 마지막 몇 필드들을 미리보기

   tail -n 80 customSpec.json

   런타임에 사용되는 sudo와 balances 팔레트같은 여러 팔레트들의 디테일을 포함한 wasm 바이너리 필드들이 보일 것임

6. 텍스트 에디터로 customSpec.json 파일 열기

7. 이 체인 스펙이 커스텀 체인 스펙이라는 걸 식별하기 위해 name 필드를 수정

"name": "My Custom Testnet",

8. 각 네트워크 참여자의 Sr25519 SS58 주소 키들을 추가함으로써 노드들의 블록 생성 권한을 명시하기 위해 aura 필드 수정

   "aura": {
    "authorities": [
      "5CfBuoHDvZ4fd8jkLQicNL8tgjnK8pVG9AiuJrsNrRAx6CNW",
      "5EJPj83tJuJtTVE2v7B9ehfM7jNT44CBFaPWicvBwYyUKBS6"
    ]
   },

9. 각 네트워크 참여자의 Ed25519 SS58 주소 키들을 추가함으로써 노드들의 블록 finalize 권한을 명시하기 위해 grandpa 필드 수정

   "grandpa": {
    "authorities": [
      [
        "5CuqCGfwqhjGzSqz5mnq36tMe651mU9Ji8xQ4JRuUTvPcjVN",
        1
      ],
      [
        "5FeJQsfmbbJLTH1pvehBxrZrT5kHvJFj84ZaY5LK7NU87gZS",
        1
      ]
    ]
   },

   grandpa에는 authorities 필드에 두 개의 데이터 값이 있다는 것에 주목. 첫 번째 값은 주소 키. 두 번째 값은 weighted votes 를 지원하는 데 사용되는 값. 여기서 각 검증자는 1투표의 무게를 가짐

10. 바꾼 거 저장파고 파일 닫기

검증자 추가

aura와 grandpa 부분을 수정하면 체인 스펙에서 권한 주소들을 추가하거나 바꿀 수 있음 원하는 만큼 많은 검증자들을 추가하기 위해 이렇게 할 것임

• aura에 Sr25519 주소들을 포함하도록 수정

• grandpa에 Ed25519 주소들과 투표 무게를 포함하도록 수정

각 검증자에 고유한 키를 사용해야 함. 만약 같은 키를 사용하면, 충돌 나는 블록 생성할 것임

raw 형식을 사용해서 체인 명세 바꾸기

체인 스펙 준비한 다음, 사용하기 전에 raw 스펙으로 바꿔어야 함 raw 체인 스펙은 그냥 체인 스펙과 같은 정보뿐만 아니라 이 노드가 로컬 스토리지에 갖고 있는 데이터를 참조하기 위해 사용하는 스토리지 키를 인코딩한 것을 가지고 있음 raw 체인 스펙을 배포해야 각 노드가 적절한 스토리지 키를 사용해 데이터를 저장한다는 것을 확신할 수 있음

1. 터미널 창 열기

2. Substrate node template을 컴파일한 곳으로 가기

3. 다음 커맨드를 실행해 customSpec.json 체인 스펙을 customSpecRaw.json 라는 이름의 raw 형식으로 바꾸기

   ./target/release/node-template build-spec --chain=customSpec.json --raw --disable-default-bootnode > customSpecRaw.json

다른 사람들과 체인 명세 공유하기

다른 참여다즐에게 공유한 프라이빗 블록체인 네트워크를 만든다면 도직 한 사람만 체인 스펙을 만들고 그 스펙의 raw 버전을 공유하도록 확신해야 함 모두가 똑같은 raw 파일을 사용해야 한다는 뜻

러스트 컴파일러가 결정적으로 재생산가능하지 않은 최적화된 웹어셈블리 바이너리를 만들기 때문에, wasm 런타임을 만드는 각 사람들ㅇ르 약간 다른 wasm 블롭을 갖고 있음. 결정적임을 확신하기 위해, 모든 블록체인 네트워크 참여자들을 반드시 같은 raw 체인 스펙을 사용해야만 함

private network 시작하기

After you distribute the custom chain specification to all network participants, you're ready to launch your own private blockchain. The steps are similar to the steps you followed in Start the blockchain using predefined accounts. If you follow the steps in this tutorial, however, you can add multiple computers to your network.

To continue, verify the following:

• You have generated or collected the account keys for at least two authority accounts.
• You have updated your custom chain specification to include the keys for block production (aura) and block finalization (grandpa).
• You have converted your custom chain specification to raw format and distributed the raw chain specification to the nodes participating in the private network.

If you have completed these steps, you are ready to start the first node in the private blockchain.

첫 번째 노드 시작

프라이빗 블록체인 네트워크의 첫 번째 참여자로서, bootnode라 불리는 첫 번째 노드를 시작할 책임이 있음

1. 터미널을 열고

2. Substrate node template을 컴파일한 디렉토리로 가기

3. 다음과 같은 커맨드를 실해앻서 커스텀 체인 스펙으로 첫 번째 노드 시작하기

./target/release/node-template \
--base-path /tmp/node01 \
--chain ./customSpecRaw.json \
--port 30333 \
--ws-port 9945 \
--rpc-port 9933 \
--telemetry-url "wss://telemetry.polkadot.io/submit/ 0" \
--validator \
--rpc-methods Unsafe \
--name MyNode01

• --base-path : 첫 번째 노드와 연관된 커스텀 위치 명시
• --chain : 커스텀 체인 스펙 명시
• --rpc-methods Unsafe : 이 블록체인이 프로덕션 세팅을 사용하지 않고 있기 때문에 안전하지 않은 커뮤니케이션 모드를 사용할 수 있도록 해줌
• --name : telemetry UI에 사람이 읽을 수 있는 이름을 붙이기 위한 옵션

미리 정의된 계정을 사용하지 않고 있기 때문에 별도로 지금 사용하고 있는 키를 키스토어에 추가해야 함

노드 작동에 대한 정보 보기

로컬 노드 시작하면 수행 중인 동작에 대해 터미널에 로그가 뜰 것임

• (state: 0x2bde…8f66, header-hash: 0x6c78…37de) : 제네시스 블록이 초기화되고 있음
• 12D3KooWLmrYDLoNTyTYtRdDyZLWDe1paxzxTw5RgjmHLfzW96SX : 로컬 노드 신원을 명시
• 이 노드에 사용된 IP address 가 로컬 호스트 127.0.0.1임을 명시

keystore에 key 추가

첫 번째 노드를 시작해도 어떤 블록들도 아직 생성되지 않고 있다. 다음으로 네트워크에 각 노드의 두 가지 탑입의 키들을 키스토어에 추가할 것이다.

각 노드에 대해:

블록 생성을 가능하게 하기 위해 aura 권한 키 추가 블록 finalize를 가능하게 하기 위해 grandpa 권한 키 추가

키를 키스토어에 추가하기 위해 로컬에서 생성한 비밀 키를 삽입하는 key 서브커맨드 사용할 수 있음

1. 터미널 열고

2. Substrate node template 컴파일한 디렉토리로 가서

3. 다음과 비슷한 커맨드로 kye 서브커맨드로 생성된 비밀 키를 aura에 추가

./target/release/node-template key insert --base-path /tmp/node01 \
--chain customSpecRaw.json \
--scheme Sr25519 \
--suri <your-secret-seed> \
--password-interactive \
--key-type aura

<your-secret-seed> 를 노드 템플릿을 사용해 생성한 첫 번째 키 페어의 비밀 구문이나 비밀 시드로 교체

4. 키 만들 때 썼던 비밀번호 입력

5. 다음 커맨드를 실행해서 key 서브커맨드로 만든 grandpa 비밀 키 추가 ```bash ./target/release/node-template key insert --base-path /tmp/node01 \

--chain customSpecRaw.json
--scheme Ed25519
--suri
--password-interactive
--key-type gran

6. 키 만들 때 쓴 비밀번호 입력

7. 다음 커맨드로 `node01`의 키가 키스토어에 있는지 확인
```bash
ls /tmp/node01/chains/local_testnet/keystore

다음과 비슷한 출력 보여줄 것임

617572611441ddcb22724420b87ee295c6d47c5adff0ce598c87d3c749b776ba9a647f04
6772616e1441ddcb22724420b87ee295c6d47c5adff0ce598c87d3c749b776ba9a647f04

다른 참여자들을 참가하게 해주기

--bootnodes와 --validator 옵션으로 다른 검증자들이 네트워크에 참여할 수 있게 해줄 수 있음

프라이빗 네트워크에서 두 번째 검증자를 추가하기 위해:

1. 터미널 열고

2. Substrate node template 컴파일한 디렉토리로 가서

3. 다음 커맨드로 두 번째 블록체인 노드 시작: ```bash ./target/release/node-template \

--base-path /tmp/node02
--chain ./customSpecRaw.json
--port 30334
--ws-port 9946
--rpc-port 9934
--telemetry-url "wss://telemetry.polkadot.io/submit/ 0"
--validator
--rpc-methods Unsafe
--name MyNode02
--bootnodes /ip4/127.0.0.1/tcp/30333/p2p/12D3KooWLmrYDLoNTyTYtRdDyZLWDe1paxzxTw5RgjmHLfzW96SX
--password-interactive

커맨드에 올바른`bootnode` 식별자를 썼는지 확인

이 노드가 그 프라이빗 네트워크의 검증자란 것을 명시하기 위해 `base-path`, `name` ,`validator` 옵션을 사용했다는 것 주목
그리고 모든 검증자들은 반드시 동일한 체인 스펙을 사용해야 함

4. 다음과 같은 커맨드 실행해서 `key` 로 만들어낸 비밀 키 `aura`에 추가:
```bash
./target/release/node-template key insert --base-path /tmp/node02 \
--chain customSpecRaw.json \
--scheme Sr25519 \
--suri <second-participant-secret-seed> \
--password-interactive \
--key-type aura

<second-participant-secret-seed>를 두 번째 키 쌍을 만들 때 얻은 비밀 구문이나 비밀 시드로 교체 aura 키 타입은 블록 생성을 위해 필요함

5. 이 키를 만들 때 쓴 비번 입력

6. 다음과 같은 커맨드 실행해서 key 로 만들어낸 비밀 키를 로컬 키스토어에 저장하도록 grandpa에 추가:

./target/release/node-template key insert --base-path /tmp/node02 \
--chain customSpecRaw.json \
--scheme Ed25519 \
--suri <second-participant-secret-seed> \
--password-interactive \
--key-type gran

<second-participant-secret-seed>를 두 번째 키 페어를 생성할 때 얻은 비밀 구문이나 비밀 시드로 교체. gran 키 타입은 블록 finalize에 필요함

블록 finalizatiion은 각 노드의 키스토어에 그들의 키를 추가하기 위해 최소한 2/3 만큼의 검증자가 필요함 체인 스펙에서 두 명의 검증자로 설정되었기 때문에, 블록 finalization은 두 번째 노드가 키를 추가한 다음에 시작됨

7. 키를 만들 때 사용한 비번 입력

8. 다음 커맨드로 node02의 키가 키스토어에 있는지 확인:

ls /tmp/node02/chains/local_testnet/keystore

다음과 비슷한 출력값 확인:

617572611a4cc824f6585859851f818e71ac63cf6fdc81018189809814677b2a4699cf45
6772616e1a4cc824f6585859851f818e71ac63cf6fdc81018189809814677b2a4699cf45

grandpa 키를 추가한 다음에 Substrate 노드를 재시작해줘야 하므로 블록들이 finalized되는 것을 보기 전에 반드시 껐다가 재시작해줘야 함

9. Control-c 눌러서 끄고

10. 다음 커맨드로 두 번째 노드 재시작: ```bash ./target/release/node-template \

--base-path /tmp/node02
--chain ./customSpecRaw.json
--port 30334
--ws-port 9946
--rpc-port 9934
--telemetry-url "wss://telemetry.polkadot.io/submit/ 0"
--validator
--rpc-methods Unsafe
--name MyNode02
--bootnodes /ip4/127.0.0.1/tcp/30333/p2p/12D3KooWLmrYDLoNTyTYtRdDyZLWDe1paxzxTw5RgjmHLfzW96SX
--password-interactive

`/tmp/node01`와 `/tmp/node02`에 있는 각각의 키스토어에 두 노드의 키를 모두 추가한 후에 재시작하면, 같은 제네시스 블록과 상태 루트 해시를 볼 수 있을 것임

그리고 각 노드는 하나의 피어를 가지고 (`1 peers`), 블록 제안을 하고(`best: #2 (0xe111…c084)`), 몇 초 뒤에 새 블록이 두 개의 노드에서 모두 finalized되는 것을 확인할 수 있음

---


# 다음 단계
지금까지 신뢰하는 참여자들로 프라이빗 블록체인을 시작하는 법을 배웠음
- 어떻게 동료 블록체인 노드를 시작하고 멈추는지
- 나만의 비밀 키 쌍을 어떻게 만드는지
- 내가 생성한 키들을 사용하는 커스텀 체인 스펙을 어떻게 만드는지
- 나의 커스텀 체인 스펙을 사용하는 프라이빗 네트워크에 어떻게 검증자를 추가하는지

더 알아보면 좋을 것들:
- [Executor](https://docs.substrate.io/v3/advanced/executor/) - 체인 스펙에 대한  중요한 컴포넌트인 웹 어셈블리 런타임에 대한 정보
- [Accounts](https://wiki.polkadot.network/docs/learn-accounts), [Key management](https://wiki.polkadot.network/docs/learn-account-generation) - 키 생성과 스토리지 옵션에 대한 정보
- [Cryptography](https://docs.substrate.io/v3/advanced/cryptography/) : 다른 키를 사용해서 서명하는 방법에 대한 정보

node-authorization 팔레트를 사용해 Substrate에서 허가형 네트워크를 구성하는 방법에 대해 다룰 것

퍼블릭 블록체인 : 모두가 노드를 운영함으로써 네트워크에 참여 가능 허가형 블록체인 : 권한있는 노드들만 블록 검증하거나 거래 전파시킬 수 있음

Proof of Existence (2번 튜토리얼)을 완료했고 Substrate의 P2P 네트워킹에 익숙하다(Private Network Tutorial 5번 튜토리얼을 완료했다)고 가정할 것임

여기서 할 것

1. 노트 템플릿에node-authorization 팔레트 추가
2. 여러 노드들을 시작하고 새로운 노드들이 참여할 수 있도록 권한 주기

학습 목표

• node-authorization 팔레트를 런타임에서 사용하는 방법 배우기
• 여러 노드들로 구성된 허가형 네트워크 만드는 법 배우기

node-authorization팔레트 추가

node-authorization 팔레트는 Substrate의 FRAME에 내장된 팔레트로, 허가형 네트워크를 위한 노드 설정을 관리 각 노드는Vec<u8> 타입의 PeerId에 의해 식별됨 각 노드를 claim한 AccountId가 PeerId를 소유함

이 팔레트에서 네트워크에 참여하고 싶은 노드들에게 권한을 주는 두 가지 방법

1. 그 사이에 어떤 연결이 허가되었는지 잘 알려진 노드들의 집합에 참여한다. 그러기 위해 거버넌스(또는 Sudo)에 의해 허가받아야 함 -> 뭔 말???

2. 특정 노드로부터 짝 연결을 요청하기. 잘 알려진 노드일 수도, 일반 노드일 수도 있음

PeerId와 연결된 노드는 반드시 하나의 주인을 가져야 함 잘 알려진 노드의 주인은 그 노드를 추가할 때 명시됨 만약 일바 노드라면, 어떤 사용자든지 해당 노드의 주인으로써 PeerId를 등록할 수 있음 가짜 등록을 막기 위해 노드 관리자는 노드를 시작하기 전에 등록해야 하고, 따라서 뒤에 그 네트워크에 등록하는 누구에게나 PeerId를 드러냄

노드의 주인은 자기의 노드에 대해 연결을 추가하고 삭제할 수 있음 정확히 말하자면, 잘 알려진 노드들 사이의 연결은 변경할 수 없고, 언제나 서로 연결될 수 있음. 대신, 잘 알려진 노드와 일반 노드 사이 또는 두 개의 일반 노드와 서브 노드들 사이의 연결을 조절할 수 있음

The node-authorization 팔레트는 노드의 연결을 설정하기 위해 offchain worker 시스템을 통합함 offchain worker가 권한이 없는 노드들에게 기본적으로 사용불가능하도록 정확한 CLI 플래그로 offchain worker를 사용해야 함

Off-chain worker : 외부 세상과 소통하기 위한 확장된 API들에 대한 접근 권한을 가짐

• 연산 결과를 발표하기 위해 체인에 거래를 제출하는 능력
• worker가 외부 서비스로부터 데이터를 가져오고 접근할 수 있게 해 주는 완전기능 HTTP client
• 선언문이나 거래를 검증하고 사인하기 위한 지역 keystore에 대한 접근권한
• 모든 off-chain worker 사이에 공유되는 지역 key-value 데이터베이스
• 랜덤 숫자 생성을 위한 안전한 지역적 엔트로피 소스
• 노드의 정확한 지역 시간에 대한 접근 권한
• 일을 쉬고 재개하는 능력 off-chain worker의 결과물은 일반 거래 검증 대상이 아님. 어떤 정보가 체인에 들어갈지 결정하기 위해 검증 메커니즘을 반드시 구현해야 함

노드 템플릿 빌드

1. 노드 템플릿 클론받기

   git clone https://github.com/substrate-developer-hub/substrate-node-template
   git checkout latest

2. 빌드하기

cd substrate-node-template/
cargo build --release

3. 좋아하는 에디터로 열기

node-authorization 팔레트 추가

1. 런타임 dependencies에 팔레트 추가

runtime/Cargo.toml

pallet-node-authorization = { default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.20" }

[features]
default = ['std']
std = [
    'pallet-node-authorization/std',
]

간단한 블록체인에서 거버넌스를 시뮬레이션해야 하므로 sudo 관리자 규칙을 만들어서 EnsureRoot에 대한 팔레트의 인터페이스를 설정할 것

runtime/src/lib.rs

use frame_system::EnsureRoot;

parameter_types! {
    pub const MaxWellKnownNodes: u32 = 8;
    pub const MaxPeerIdLength: u32 = 128;
}

impl pallet_node_authorization::Config for Runtime {
    type Event = Event;
    type MaxWellKnownNodes = MaxWellKnownNodes;
    type MaxPeerIdLength = MaxPeerIdLength;
    type AddOrigin = EnsureRoot<AccountId>;
    type RemoveOrigin = EnsureRoot<AccountId>;
    type SwapOrigin = EnsureRoot<AccountId>;
    type ResetOrigin = EnsureRoot<AccountId>;
    type WeightInfo = ();
}

construct_runtime 매크로에 우리의 팔레트를 추가하기

runtime/src/lib.rs

construct_runtime!(
    pub enum Runtime where
        Block = Block,
        NodeBlock = opaque::Block,
        UncheckedExtrinsic = UncheckedExtrinsic
    {
        NodeAuthorization: pallet_node_authorization,
    }
);

팔레트에 genesis storage 추가

node/Cargo.toml

[dependencies]
bs58 = "0.4.0"

PeerId는 bs58 형식으로 인코딩되어 있기 때문에, 해독해서 바이트 얻어내려면 bs58 라이브러리 추가

node/src/chain_spec.rs

use sp_core::OpaquePeerId;
use node_template_runtime::NodeAuthorizationConfig; 

적절한 genesis storage와 필요한 의존성 추가

fn testnet_genesis(
    wasm_binary: &[u8],
    initial_authorities: Vec<(AuraId, GrandpaId)>,
    root_key: AccountId,
    endowed_accounts: Vec<AccountId>,
    _enable_println: bool,
) -> GenesisConfig {
        node_authorization: NodeAuthorizationConfig {
            nodes: vec![
                (
                    OpaquePeerId(bs58::decode("12D3KooWBmAwcd4PJNJvfV89HwE48nwkRmAgo8Vy3uQEyNNHBox2").into_vec().unwrap()),
                    endowed_accounts[0].clone()
                ),
                (
                    OpaquePeerId(bs58::decode("12D3KooWQYV9dGMFoRzNStwpXztXaBUjtPqi6aU76ZgUriHhKust").into_vec().unwrap()),
                    endowed_accounts[1].clone()
                ),
            ],
        },
}

헬퍼 함수 testnet_genesis()에 genesis 설정 추가

NodeAuthorizationConfig는 nodes라는 튜플의 벡터인 property를 가짐 튜플의 첫 번째 요소는 OpaquePeerId 이고 이걸 사람이 읽을 수 있는 형식에서 byte로 바꾸기 위해 bs58::decode 사용 튜플의 두 번째 요소는 AccountId 이고, 이 노드의 주인을 나타내며, 설명을 위해 제공된 Alice와 Bob 계정을 사용할 것

12D3KooWBmAwcd4PJNJvfV89HwE48nwkRmAgo8Vy3uQEyNNHBox2가 어디서 나왔는지 궁금할 텐데, 위의 사람이 읽을 수 있는 PeerId를 생성하기 위해 subkey(CLI 툴)를 사용할 수 있음

subkey generate-node-key

실행 결과는 다음과 같음:

12D3KooWBmAwcd4PJNJvfV89HwE48nwkRmAgo8Vy3uQEyNNHBox2 // this is PeerId.
c12b6d18942f5ee8528c8e2baf4e147b5c5c18710926ea492d09cbd9f6c9f82a // This is node-key.

이제 허가형 네트워크 시작할 준비 끝

허가형 네트워크 시작하기

허가형 체인을 어떻게 시작하고 새 노드를 추가하는지 알아볼 것임

먼저 다 잘 컴파일 되는지 확인:

cargo build --release

4개의 노드를 시작할 것 : 3개의 잘 알려진 노드로 주인에게 허가받고 블록을 검증하는 것과, 선택된 잘 알려진 노드로부터 읽기 전용 권한만을 갖는 1개의 서브노드

노드 키와 PeerID 얻기

Alice의 잘 알려진 노드:

# Node Key
c12b6d18942f5ee8528c8e2baf4e147b5c5c18710926ea492d09cbd9f6c9f82a

# Peer ID, generated from node key
12D3KooWBmAwcd4PJNJvfV89HwE48nwkRmAgo8Vy3uQEyNNHBox2

# BS58 decoded Peer ID in hex:
0x0024080112201ce5f00ef6e89374afb625f1ae4c1546d31234e87e3c3f51a62b91dd6bfa57df

Bob의 잘 알려진 노드

# Node Key
6ce3be907dbcabf20a9a5a60a712b4256a54196000a8ed4050d352bc113f8c58

# Peer ID, generated from node key
12D3KooWQYV9dGMFoRzNStwpXztXaBUjtPqi6aU76ZgUriHhKust

# BS58 decoded Peer ID in hex:
0x002408011220dacde7714d8551f674b8bb4b54239383c76a2b286fa436e93b2b7eb226bf4de7

Charlie의 일반 노드

# Node Key
3a9d5b35b9fb4c42aafadeca046f6bf56107bd2579687f069b42646684b94d9e

# Peer ID, generated from node key
12D3KooWJvyP3VJYymTqG7eH4PM5rN4T2agk5cdNCfNymAqwqcvZ

# BS58 decoded Peer ID in hex:
0x002408011220876a7b4984f98006dc8d666e28b60de307309835d775e7755cc770328cdacf2e

Dave의 (Charlie에 대한) 서브노드

# Node Key
a99331ff4f0e0a0434a6263da0a5823ea3afcfffe590c9f3014e6cf620f2b19a

# Peer ID, generated from node key
12D3KooWPHWFrfaJzxPnqnAYAoRUyAHHKqACmEycGTVmeVhQYuZN

# BS58 decoded Peer ID in hex:
0x002408011220c81bc1d7057a1511eb9496f056f6f53cdfe0e14c8bd5ffca47c70a8d76c1326d

Alice와 Bob의 노드는 미리 genesis storage에 잘 알려진 노드로 설정해둠. 앞으로 Charlie의 노드를 잘 알려진 노드로 추가하고 Charlie의 노드와 Dave의 노드 사이의 연결을 Dave의 노드를 잘 알려진 노드로 만들지 않으면서 추가할 것

Alice와 Bob으로 네트워크 시작

먼저 Alice 노드 시작:

./target/release/node-template \
--chain=local \
--base-path /tmp/validator1 \
--alice \
--node-key=c12b6d18942f5ee8528c8e2baf4e147b5c5c18710926ea492d09cbd9f6c9f82a \
--port 30333 \
--ws-port 9944

여기서 --node-key를 사용해 네트워크 연결의 보안을 위해 사용할 키를 명시하고 있음 이 키는 위에 있는 사람이 읽을 수 있는 PeerId를 생성하는 데에도 내부적으로 사용됨

• --chain=local : --dev랑은 다른 로컬 테스트넷을 위해 사용
• --alice : 노드에게 alice라는 이름을 붙여주면서 누가 주인이고 블록을 완성할 것인지에 대한 권한을 줌
• --port : P2P 연결을 위한 포트 할당
• --ws-port : Websocket 연결을 위한 수신 포트 할당

Bob 노드 시작

# In a new terminal, leave Alice running
./target/release/node-template \
--chain=local \
--base-path /tmp/validator2 \
--bob \
--node-key=6ce3be907dbcabf20a9a5a60a712b4256a54196000a8ed4050d352bc113f8c58 \
--port 30334 \
--ws-port 9945

두 개의 노드 다 실행시키면 터미널 로그로 새로운 블록들이 생성되고 완료되는 걸 볼 수 있음 이제 polkadot.js app으로 잘 알려진 노드들을 확인해볼 것 로컬 노드 중 하나를 127.0.0.1:9944 나 127.0.0.1:9945로 바꾸는 거 잊지 말기

Developer page로 가서,Chain State sub-tab에서 nodeAuthorization 팔레트의 wellKnownNodes storage에 저장된 데이터 확인 Alice와 Bob 노드의 peer id가 0x가 붙은 16진수 형식으로 보일 것임

스토리지에 We can also check the owner of one node by querying the storage owners 스토리지에 노드의 peer id를 입력값으로 쿼리 날려서 주인의 계정 주소를 얻음으로써 노드의 주인을 확인할 수 있음

또다른 잘 알려진 노드 추가

Charlie 노드 시작

./target/release/node-template \
--chain=local \
--base-path /tmp/validator3 \
--name charlie  \
--node-key=3a9d5b35b9fb4c42aafadeca046f6bf56107bd2579687f069b42646684b94d9e \
--port 30335 \
--ws-port=9946 \
--offchain-worker always

시작한 뒤에도 이 노드에 연결된 peer가 없는 것을 볼 수 있을 것임 이건 허가형 네트워크이기 때문에 연결되기 위해선 허가를 받아야 함! Alice와 Bob은 처음에 chain_spec.rs에서 미리 설정해뒀음

거버넌스를 위해 sudo 팔레트를 사용하고 있어서 노드를 추가하기 위해node-authorization 팔레트가 제공하는add_well_known_node dispatch를 sudo 호출할 수 있다는 걸 기억해라

Developer page의 Sudo tab으로 가서 Charlie를 주인으로 해서 Charlie의 16진수 peer id를 넣고 nodeAuthorization 의 add_well_known_node 을호출 이 호출에 대해 Alice가 유효한 sudo origin이라는 거에 주목해라

이 거래가 블록에 포함된 뒤, Charlie의 노드가 Alice와 Bob의 노드에 연결되고 블록을 맞춰 나가는 걸 불 수 있을 것임 세 노드들이 서로를 찾을 수 있는 이유는 mDNS discovery 메커니즘이 로컬 네트워크에 기본 설정으로 사용가능하기 때문

이제 모든 블록들을 같이 검증하는 3개의 잘 알려진 노드들이 있음

Dave를 Charlie의 서브노드로 추가

이제 Dave의 노드를 잘 알려진 노드가 아니라 Charlie의 "서브 노드"로 추가할 것 Dave는 네트워크에 접근하기 위해 오직 Charlie에게만 연결할 수 있음 보안 기능 때문임: Charlie는 어떤 연결된 서브노드에 대해 혼자 책임을 짐 제거될 때 David에 대한 접근 권한은 한 곳에서만 하면 됨

Dave의 노드 시작

./target/release/node-template \
--chain=local \
--base-path /tmp/validator4 \
--name dave \
--node-key=a99331ff4f0e0a0434a6263da0a5823ea3afcfffe590c9f3014e6cf620f2b19a \
--port 30336 \
--ws-port 9947 \
--offchain-worker always

시작하면, 가능한 연결이 없을 것임 먼저, Charlie가 Dave의 노드로부터 연결을 허용하기 위해 노드 설정해줘야 함

Developer Extrinsics page에 가서 Charlie 계정으로 addConnections extrinsic 호출 peerId는 Charlie 노드의 16진수 peer id임. connections는 Charlie의 노드에 대해 허용된 노드들의 리스트인데, 우리는 Dave 노드만 추가할 것임

이제 Chalie의 노드로부터 연결을 허락받기 위해 Dave가 노드 설정해야 함 그 전에 너무 늦기 않았기를 바라면서 Dave의 노드를 먼저 등록해야 함!

비슷하게, Dave는 Charlie 노드로부터 연결 추가할 수 있음

이제 Dave가 블록들을 따라잡고 있고, 오직 Chalie만을 peer로 갖는 걸 볼 수 있음! Chalie와 바로 연결되지 않는 경우에는 Dave의 노드를 다시 시작하면 됨

remove_well_known_node이나 remove_connections 등의 extrinsic으로도 놀아보기

다음 단계

Private Network Tutorial 완료하기 Subkey tool 더 알아보기

0. 복습

React JSX DOM element

const element = <h1 title="foo">Hello</h1>
const container = document.getElementById("root")
ReactDOM.render(element, container)

JSX는 유효한 바닐라 자바스크립트 문법이 아니기 때문에 바벨과 같은 빌드 도구를 사용해 JS 문법으로 바꾼다. 태그 안에 있는 코드를 createElement()에 태그 이름과 props, children을 인자로 넘겨줌으로써 바꾼다. React.createElement()함수는 인자들로부터 객체 하나를 만드는데, 주요하게 type과 props라는 두 가지의 properties를 살펴보겠다

type은 우리가 만들고 싶어 하는 DOM 노드의 타입을 명시한 문자열로, 태그 이름이다.

props는 또 다른 객체로써, JSX attributes로부터 모든 key와 value들을 가지고 있다. 그 중의 특별한 property로 children이 있는데, 문자열 또는 다른 element들의 배열이다.

ReactDOM.render()는 어떻게 바꿀 수 있을까? 먼저 element의 type을 사용해 노드를 하나 만들고 모든 props를 해당 노드에게 할당해주면 된다 그런 다음, children을 위한 노드들을 만드는데, 여기서는 문자열만 가지므로 textNode를 사용해 노드 하나를 만들겠다. 이때, 이 노드가 {nodeValue: 'hello'}라는 값을 갖고 있는 것처럼 nodeValue를 설정해준 것에 주목

마지막으로 textNode를 h1에 추가하고 h1을 container에 추가한다

const element = {
  type: "h1",
  props: {
    title: "foo",
    children: "Hello",
  },
}

const container = document.getElementById("root")

const node = document.createElement(element.type)
node["title"] = element.props.title

const text = document.createTextNode("")
text["nodeValue"] = element.props.children

node.appendChild(text)
container.appendChild(node)

1. createElement()

앞에서 봤듯이, element는 type과 props를 가지고 있는 object일 뿐이다. 따라서 createElement()함수가 해야 할 일도 object를 만들기만 하면 된다

function createElement(type, props, ...children) {
  return {
    type,
    props: {
      ...props,
      children,
    },
  }
}

예를 들어,

• createElement("div")는 {type: "div", props: {children:[]}}을 리턴하고 - createElement("div", null, a)는 {type: "div", props: {children: [a]}}를 리턴하고,
• createElement("div", null, a, b)는 {type: "div", props: {children:[a, b]}}를 리턴한다

function createTextElement(text) {
  return {
    type: "TEXT_ELEMENT",
    props: {
      nodeValue: text,
      children: [],
    },
  }
}

children 배열은 문자열이나 숫자같은 원시값도 포함해야 한다. 그래서 객체가 아닌 것들을 감싸서 특별한 타입: TEXT_ELEMENT를 만들 것이다.??? 먼말인데....

const Didact = {
  createElement,
}

/** @jsx Didact.createElement */
const element = (
  <div id="foo">
    <a>bar</a>
    <b />
  </div>
)

우리 코드에 이름 붙이고 바벨이 리액트 말고 내 꺼 쓰게 하는 주석 추가함

2. render()

ReactDOM.render() 대체하는 함수 만들어보기~~ 일단 DOM에 element 추가하는 기능만 넣을것임

function render(element, container) {
  const dom =
    element.type == "TEXT_ELEMENT"
      ? document.createTextNode("")
      : document.createElement(element.type)

  const isProperty = key => key !== "children"
  Object.keys(element.props)
    .filter(isProperty)
    .forEach(name => {
      dom[name] = element.props[name]
    })

  element.props.children.forEach(child =>
    render(child, dom)
  )

  container.appendChild(dom)
}

재귀적으로 children에 대해 render 호출해주고~ 타입이 text_element인 경우에는 textnode 만들어주기 isProperty 부분은 element prop을 그 노드에 할당하는 것??? 뭔말이야...

3. Concurrnet 모드

만약에 element tree가 넘 깊다면, 메인 스레드를 계속 블락하고 있을 것임 렌더 함수의 재귀 호출 부분을 최적화해야 함

렌더링 하는 부분 작게 쪼개서 각 부분 완료하면 브라우저가 중간에 끼어들 수 있도록 할 것임

루프를 만들기 위해 requestIdleCallback을 사용할 것임, 메인 스레드가 놀고 있을 때 콜백함수 실행하는 아이임

let nextUnitOfWork = null

function workLoop(deadline) {
  let shouldYield = false
  while (nextUnitOfWork && !shouldYield) {
    nextUnitOfWork = performUnitOfWork(
      nextUnitOfWork
    )
    shouldYield = deadline.timeRemaining() < 1
  }
  requestIdleCallback(workLoop)
}

requestIdleCallback(workLoop)

function performUnitOfWork(nextUnitOfWork) {
  // TODO
}

requestIdleCallback에 deadline 인자를 줄 수 있음 브라우저가 끼어들 때까지 텀을 얼마나 줄 것인지 설정하는 것임

먼저 초기 unitOfWork를 설정해주고 그 work 수행하면서 다음 unitOfWork를 리턴해주는 performUnitOfWork함수를 작성할거심

4. Fibers

작업 단위를 정리하기 위해 fiber tree 자료구조가 필요함

각 element당 하나의 fiber를 둘 거고, 각 fiber아 작업 단위가 될 것임

Didact.render(

function commitRoot() {
  commitWork(wipRoot.child)
  wipRoot = null
}
​
function commitWork(fiber) {
  if (!fiber) {
    return
  }
  const domParent = fiber.parent.dom
  domParent.appendChild(fiber.dom)
  commitWork(fiber.child)
  commitWork(fiber.sibling)
}

/** @jsx Didact.createElement */
function App(props) {
  return <h1>Hi {props.name}</h1>
}
const element = <App name="foo" />
const container = document.getElementById("root")
Didact.render(element, container)

function App(props) {
  return Didact.createElement(
    "h1",
    null,
    "Hi ",
    props.name
  )
}
const element = Didact.createElement(App, {
  name: "foo",
})

function updateFunctionComponent(fiber) {
  const children = [fiber.type(fiber.props)]
  reconcileChildren(fiber, children)
}

특정 dom을 잡아야 할때 ref를 사용합니다. ref를 쓸 때, createRef와 useRef 두 방식으로 ref를 만들 수 있습니다.

class 컴포넌트

class형 컴포넌트에서는 아래와 같은 예제로 createRef를 통해 ref를 사용합니다. class App extends React.Component { componentDidMount() { this.divRef = React.createRef(); } render() { return (

함수형 컴포넌트

함수형 컴포넌트에서는 useRef를 사용합니다. import React, { useRef } from "react";

const App = () => { const divRef = React.useRef(); const valueRef = React.useRef(90); return (

export default App;

위 코드를 실행하면 valueRef값이 88로 바뀌지 않는 다는 것을 알 수 있습니다. 만약 반응형으로 바뀌도록 의도한다면, 일부러 useState를 실행하면 됩니다. import React, { useState, useRef } from "react";

const App = () => { const divRef = React.useRef(); const valueRef = React.useRef(90); const [, setState] = useState(); return (

export default App;

그러나 createRef를 함수형 컴포넌트에서 사용할 경우 문제점이 있습니다. 예를 들어 함수형 컴포넌트에서 createRef를 사용하면 import React, { useState, createRef } from "react";

const App = () => { const valueRef = createRef(); const [, setState] = useState(); return (

export default App;

렌더링의 문제는 없지만, 증가 버튼을 클릭해도 이전 과 같이 88로 바뀌지 않는 다는 것을 볼 수 있습니다. 이유는 App 컴포넌트가 setState에 의해 리렌더링 되면 App 컴포넌트를 초기화 하고 다시 만듭니다. 그에 따라 createRef도 다시 실행되는데, 이 때 createRef에 의해 만들어진 값은 무조건 null로 다시 초기화 됩니다. react의 createRef 코드 (opens new window)를 참고하세요 그래서 함수혐 컴포넌트의 수명 내내 ref의 current 값을 유지하기 위해 useRef hook이 만들어진 것입니다. useRef로 만들어진 값은 함수가 리렌더링 되어도 ref가 null로 초기화 되지 않습니다. (ref 값이 다시 재생성되지 않음)

결론

class형 컴포넌트에서 ref를 잡아야하는 경우 React.createRef를 사용한다. 함수형 컴포넌트의 경우 React.createRef와 React.useRef 둘다 사용가능 하지만 React.createRef를 사용할 경우 리렌더링 될때마다 ref 값이 초기화되어 원하는 값을 얻지 못할 것이다. 그러니 useRef를 사용한다.

Ref란? 특정 노드나 컴포넌트에 레퍼런스 값을 만들어주는 것입니다. 때문에 Ref를 통해서 노드나 리액트 요소에 접근하여 값을 얻어낼 수 있습니다. 레퍼런스를 만들기 위해선 리액트 내장함수인 createRef와 리액트 훅인 useRef() 가 있는데요. createRef는 클래스형 컴포넌트 useRef()는 함수형 컴포넌트에서 사용합니다. 먼저 클래스형 컴포넌트의 createRef의 코드를 살펴보겠습니다. 클래스형 컴포넌트 코드 살펴보기 import React, { useState } from "react";

import React, { Component } from "react";

class App extends Component { state = { text: [], };

//레퍼런스를 만들기 위한 리액트 내장함수 //레퍼런스명 = React.createRef(); inputRef = React.createRef(); handleAddText = (e) => { e.preventDefault();

//해당 레퍼런스(여기서는 input)의 현재 밸류값 가져오기
const newText = [this.inputRef.current.value, ...this.state.text];
this.setState({ text: newText });

}; render() { return (

    //가져오고 싶은 요소에 레퍼런스 속성 및 레퍼런스명 지정
      <input ref={this.inputRef} />
      <button>버튼</button>
    </form>
    <ul>
      {this.state.text.map((item) => {
        return <li>{item}</li>;
      })}
    </ul>
  </div>
);

} } export default App;

함수형 컴포넌트 코드 살펴보기

import React, { useState, useRef } from "react";

function App() { const [text, setText] = useState([]); const inputRef = useRef(); const handleAddText = (e) => { e.preventDefault(); setText([inputRef.current.value, ...text]); };

return (

버튼

{text.map((item) => { return
• {item}
; })}

); }

export default App;

이런식으로 같은 결과물인 클래스형과 함수형 컴포넌트 각자의 코드를 구성해보았습니다. 먼저, createRef라는 리액트 내장 함수를 이용하여 ref의 명을 만들어줍니다.(함수형에선 useRef라는 리액트 훅 이용) 둘째, 접근하고 싶은 돔 요소에 ref속성을 넣어준 후 첫번째에 만들어준 ref명을 넣어줍니다. 셋째, inputRef.current.value 이런식으로 그 ref에 현재 접근한 것의 value값을 가져오는 식을 적어주면 해당 input의 value값을 가져 옵니다.

createRef와 useRef의 차이점

클래스형 컴포넌트는 인스턴스를 생성 후 render 코드 블록 쪽만 리랜더링후 다시 실행 합니다. 하지만 함수형 컴포넌트는 함수 블록 안에 있는 모든 것을 리랜더링시 마다 다시 실행합니다. 때문에, 함수형 컴포넌트에 createRef를 사용 할 시 ref 값이 초기화 되어서 원하는 값을 얻지 못하기 떄문에, 리액트 훅인 useRef를 사용하는 것입니다. 리액트 훅을 사용하면 useState 값을 리랜더링하면 내부적으로 기억하듯이 useRef도 내부적으로 ref값을 기억하여줍니다.

이렇게 ref는 돔요소나 리액트 컴포넌트등에 접근하여 원하는 값을 가져올 수 있게 해주는 고마운 존재입니다. 감사합니다 useRef Hooks에서만 실행 가능 ref를 만들고 ref의 초기값을 할당함 빈값으로 시작하지 않으므로 빈값 체크할 필요가 없음 createRef 함수 컴포넌트, 클래스 컴포넌트 둘다 사용 ref만 만듬 값을 가져다가 쓸 때 빈값 체크가 필요함

1. 변경 가능한 값 우선 React에서 Ref는 Reference의 줄임말이고 DOM 요소를 참조한다고 해서 붙인 이름 같네요. useRef()는 인자하나를 초기값으로 받고 reference를 return합니다. reference는 current라는 특별한 프로퍼티를 가진 객체입니다. const reference = useRef(initialValue);

reference.current; // current reference value

refer.current는 레퍼런스의 값에 접근하고 refer.current = newValue는 레퍼런스의 값을 업데이트 합니다. import { useRef } from 'react';

function MyComponent() { const reference = useRef(initialValue);

const someHandler = () => { // Access reference value: const value = reference.current;

// Update reference value:
reference.current = newValue;

};

// ... }

여기서 두가지 규칙을 기억해야 합니다. 레퍼런스의 값은 유지 됩니다. 컴포넌트 리렌더링이 된다 하더라도. 레퍼런스의 값의 업데이트는 컴포넌트 리렌더링을 트리거하지 않습니다. 간단한 예제 import { useRef } from 'react';

function LogButtonClicks() { const countRef = useRef(0);

const handle = () => { countRef.current++; console.log(Clicked ${countRef.current} times); };

console.log('I rendered!');

return Click me; }

버튼을 클릭하더라도 I rendered 로그는 나타나지 않고(규칙2), Clicked 1 times에서 값은 계속 증가합니다.(규칙1) Ref와 State의 차이는? Ref와 state의 차이를 위해 코드를 써 봅니다. import { useState } from 'react';

function LogButtonClicks() { const [count, setCount] = useState(0);

const handle = () => { const updatedCount = count + 1; console.log(Clicked ${updatedCount} times); setCount(updatedCount); };

console.log('I rendered!');

return Click me; }

state의 update가 있기에 클릭을 할 때마다 I rendered! 로그를 보실 수 있습니다. 해당 코드를 바탕으로 알 수 있는 state와 ref의 두가지 주요한 차이점을 알 수 있습니다. state를 업데이트하는 것은 컴포넌틑 리렌더링을 트리거하지만 ref는 아닙니다. 상태 업데이트는 비동기적(상태 변수는 렌더링 한 후 업데이트 됨)이지만 참조는 동기적(업데이트된 값은 즉시 사용될 수 있음)입니다. 2. DOM 요소 접근 아래 3단계 과정은 useRef를 이용해 DOM 요소에 접근하는 예제입니다. useRef를 이용해 elementRef 선언. elementRef를 div에 할당 컴포넌트가 마운트 되고나서 엘리먼트의 ref속성을 divElement에 할당 import { useRef, useEffect } from 'react';

function AccessingElement() { const elementRef = useRef();

useEffect(() => { const divElement = elementRef.current; }, []);

return (

I'm an element

); }

2-1 사용 사례 : 인풋 포커싱 예를 들어, 컴포넌트가 마운트되고 인풋 필드에대한 포커싱이 필요하다면 DOM 요소들에 대한 접근이 필요합니다. 사용법은 간단합니다. import { useRef, useEffect } from 'react';

function InputFocus() { const inputRef = useRef();

useEffect(() => { inputRef.current.focus(); }, []);

return ( ); }

inputRef를 선언하고, input 태그에 할당한다. 그리고 React는 마운트 후 inputRef.current를 입력 요소로 설정합니다. 그럼 이제 실질적으로 inputRef.current.focus()를 이용해 포커싱을 줄 수 있습니다. '초기 렌더링 상태에서는 Ref는 null 이다' import { useRef, useEffect } from 'react';

function InputFocus() { const inputRef = useRef();

useEffect(() => { // Logs HTMLInputElement console.log(inputRef.current);

inputRef.current.focus();

}, []);

// Logs undefined during initial rendering console.log(inputRef.current);

return ; }

초기 렌더링 중에는 아직까지 컴포넌트는 생성된 구조가 없다. 그렇기 때문에 초기 렌더링 중에 inputRef.current가 undefined로 나타납니다. useEffect 단계에서는 DOM이 렌더되고나서 콜백을 호출한다. useEffect에서는 DOM이 보장되기 때문에 올바르게 inputRef.current에 액세스할 수 있다. 3. 참조 제한 업데이트 함수 컴포넌트의 함수 스코프는 output을 계산하거나 hook을 호출해야한다. 그래서 컴포넌트 함수의 즉각적인 범위 내에서 참조 업데이트(상태 업데이트 포함)를 수행해서는 안된다. 참조는 useEffect()의 콜백 내부 또는 핸들러(이벤트, 타이머)내부에서 업데이트 되어야한다. import { useRef, useEffect } from 'react';

function MyComponent({ prop }) { const myRef = useRef(0);

useEffect(() => { myRef.current++; // Good!

setTimeout(() => {
  myRef.current++; // Good!
}, 1000);

}, []);

const handler = () => { myRef.current++; // Good! };

myRef.current++; // Bad!

if (prop) { myRef.current++; // Bad! }

return My button; }

4.정리 useRef()는 참조를 생성한다. const reference = useRef(initialValue)는 초기값과 함께 특별한 객체를 생성한다. 참조 객체는 current프로퍼티를 가지고 있다. refer.current를 읽거나 업데이트할 수 있다. 참조 값은 컴포넌트 리렌더링과 별개로 영구적이다. state의 업데이트와 다르게 참조 업데이트는 컴포넌트 리렌더링을 트리거하지 않는다. 참조는 DOM에 접근할 수 있다.

Element

처럼 할당하고 reference.current를 이용해 접근할 수 있다. [React] useRef, ref 란 무엇일까? React에서 제공하는 hook, useRef에 대해서 알아보자. (전체적인 코드는 작성하지 않음, 해당 git 링크에서 clone 받아서 확인 가능) useRef useRef는 무엇이고 왜 사용할까? 자세히 들어가면 한도 끝도 없고, 그 정도까지 알 필요도 없다(심화는 천천히). 간단하게만 알아보자. ref는 크게 2가지로 사용이 된다.

1. DOM에 접근한다.

2. 렌더링을 일으키지 않고 값을 변경시킨다. 우선 위 2가지를 알아보자.

3. DOM에 접근한다. JavaScript에서 DOM에 접근할 때 사용하는 여러가지 방법이 있다. DOM에 접근하는 대표적인 방법이 Document.querySelector(), Document.getElementById()가 있다. 이러한 것들을 대신 ref을 이용하여 DOM에 접근할 수 있다. 간단하게 예시를 들어보자. 아래 코드는 버튼을 클릭하였을 때, input 창에 focus를 하는 코드이다. return (

   textRef.current.focus()}> input에 포커스하기
   ); 결과를 보면 알 수 있듯이 input 창에 포커싱이 된다.

4. 렌더링을 일으키지 않고 값을 변경시킨다. 렌더링을 일으키지 않고 값을 변화시킬 수 있다? 이게 무슨 말일까? 이전 시간에 알아본 state는 값이 변할 때마다 setState를 해주어서 렌더링이 되는 것을 확인하였다. 그러나 ref는 state와 다르게 값이 변하게 되어도 렌더링이 일어나지 않는다. 간단하게 구현하여 확인해보자. const Ref = () => { const textRef = useRef(null);

   console.log("rendering");

   return (

   console.log("input 값 : ", textRef.current.value)}> 값 확인하기
   ); };

위 gif를 보면 알 수 있듯이 input에 값을 계속 변화를 주지만 렌더링은 일어나지 않는다. 그럼 저 값을 가지고 오고 싶으면 어떻게 해야할까? 바로 ref.current를 이용하여 DOM에 접근하여 값을 가지고 오는 것이다. 사실 1번 DOM에 접근할 수 있다와 연관이 있는 내용이다. Controlled(제어) 컴포넌트, Uncontrolled(비제어) 컴포넌트 React에는 제어 컴포넌트와 비제어 컴포넌트가 있다. 간단하게 2개의 차이만 말하자면 제어 컴포넌트는 state를 사용한 것이고, 비제어 컴포넌트는 ref를 사용한 것이다. 2개의 차이점은 분명히 존재한다. React에서는 제어 컴포넌트를 지향하고 있다. 그러나 state를 사용하는 경우 복잡한 form을 구현할 때, 렌더링이 많이 일어나 성능상 느려지는 경우가 발생할 수 있다. 따라서 제어, 비제어 컴포넌트를 상황에 맞게 잘 사용해야 한다. 해당 부분은 아래 걸어둔 React 공식 홈페이지 링크를 읽어보도록 하자.

• 제어 컴포넌트
• 비제어 컴포넌트

React 라이브러리는 ref를 왜 만들었을까? 이 글은 해당 질문을 중심으로 ref와 연관된 아래 개념들을 정리하는 글이다. 01. DOM API(querySelector, getElementById) 02. Mutable(변하기 쉬움)과 Immutable(불변성) 03. Declarative(선언형)과 Imperative(명령형) React에서 Ref Vanilla Javascript에서는 DOM 객체에 접근하기 위해 querySelector나 getElementById API를 사용해야 한다. 반면, React는 아래와 같은 이유로 DOM API를 이용한 컴포넌트 제어 방식을 권장하지 않는다. 01. React를 이용한 웹 소프트웨어에서 데이터는 State로 조작되기에 DOM API와 혼합해서 데이터 및 조작을 할 경우 디버깅이 어려워지고, 유지보수가 어려운 코드가 된다. 02. map 메소드를 이용해 렌더링 되는 리스트 형태의 Element는 같은 ID를 가지기에 특정 DOM 객체를 querySelector, getElementById로 판별하기 어렵다. 따라서, React는 DOM API를 이용한 컴포넌트 제어 대신 ref라는 기능을 제공한다. ref를 통해 DOM 객체에 대한 직접적인 참조 주소를 반환 받아 HTML DOM 메소드 및 속성을 이용할 수 있다. [그림 01] HTML DOM 속성에 접근하는 ref의 예시. clientHeight는 HTML DOM의 주요 속성이다. React에서는 ref기능을 이용하기 위해 React.createRef() 와 useRef() 를 제공한다. 이 둘을 간략하게 구분하면 Class 컴포넌트에서는 createRef()를 사용하고 Functional 컴포넌트에서는 useRef()를 사용한다. 이 둘에 대한 차이는 잠시 미뤄두고 각 기능은 다음과 같이 사용한다. [그림 02] Class 컴포넌트에서 React.createRef()를 써서 ref를 만드는 예시. current라는 속성으로 값을 조회함 이때, 중요한 것은 createRef()와 useRef()자체는 Mutable Object를 만드는 기능이라는 점이다. ref는 componentDidMount나 useEffect가 실행되기 전에 할당됩니다. 컴포넌트가 마운트 될 때 할당되며, 언마운트 될 때 Null을 할당합니다. 즉, React Component의 인스턴스나, React DOM의 ref 속성에 해당 ref 참조(this.ref)를 선언하지 않으면 그저 Mutable Object일 뿐이다. 이를 확인하기 위해 createRef의 실제 구현체를 확인해보자. [그림 03] React.createRef()의 실제 구현체. Object가 Reference 타입의 자료형임을 이용했다. 실제로 createRef()의 구현체를 확인하면 Javascript의 Object가 Reference(참조) 타입의 변수라는 것을 이용한 간단한 코드로 구현된 것을 확인할 수 있다. 즉, createRef()나 useRef()로 생성한 참조주소를 JSX의 ref 속성으로 선언해주어야 해당 컴포넌트 혹은 DOM Element에 대한 참조를 얻을 수 있다. createRef와 useRef 앞서 Class 컴포넌트에서는 createRef()를 Functional 컴포넌트에서는 useRef()를 쓴다고 언급했다. 이 둘의 차이는 무엇일까? 이 둘의 차이를 이해하기 위해서는 Class 컴포넌트와 Functional 컴포넌트의 리렌더링 차이를 알아야 한다. 글의 진행을 위해 간단하게 설명하면 Class 컴포넌트는 인스턴스를 생성해 render 메소드를 호출하는 방식으로 리렌더링을 한다면, Functional 컴포넌트는 해당 함수를 리렌더링 마다 다시 실행한다. 위와 같은 차이는 Functional 컴포넌트에서 createRef() 메소드를 이용하기 어렵게 한다. 아래 예시 코드를 보자. [그림 04] Functional 컴포넌트에 createRef를 쓸 경우 Component가 렌더링 될 때마다 ref가 생성된다. createRef()는 앞서 확인한 것과 같이 그저 Mutable Object를 생성하는 기능이기에 Functional 컴포넌트에서 리렌더링 될 때마다 새로운 Mutable Object를 생성하게 된다. 즉, ref를 이용해 Mutable Object를 만들어도 state가 변경되면 createRef()가 다시 호출되며 새로운 ref를 반환한다. [그림 05] useRef의 구현체로 별도의 Dispatcher에서 해당 컴포넌트의 Hook을 관리함 이와 같은 문제를 해결하기 위한 방법으로 React에서는 useRef()라는 기능을 제공한다. useRef는 Hook의 Dispatcher를 통해서 동작하는데 내부적으로 mountRef와 updateRef 를 이용해 동작하는 것을 확인할 수 있다. [그림 06] useRef의 내부 동작을 담당하는 mountRef와 updateRef의 구현체 mountRef와 updateRef 구현체를 통해 두 가지 사실을 알 수 있다. 첫번째, mountRef는 현재의 Hook에 대한 정보를 보관하는 Object의 memoizedState라는 속성에 ref를 저장하는 방식으로 구현됐다. 두번째, updateRef는 컴포넌트가 업데이트 되어 리 렌더링이 발생할 때 memoizedState를 반환하는 방식으로 구현됐다. useImperativeHandle와 ForwardRef React는 기본적으로 Declarative(선언형) 패러다임을 따른다. 즉, 뷰의 동작에 대해 하나 씩 명시하는 것이 아닌 state나 props의 변경에 따라 변하는 뷰를 선언하는 방식으로 개발된다. 하지만, Ref 기능의 경우 기능을 조작하기 위해 Imperative(명령형) 패러다임을 따른다. 아래의 코드를 보자. [그림 07] Imperative(명령형) 패러다임을 따르는 ref 기능 특정 동작에 대한 메소드를 구현하고 Imperative(명령형) 패러다임으로 개발하는 것을 확인할 수 있다. ref를 통한 이런 기능은 Class 컴포넌트에서는 기본적으로 동작하지만 내부 메소드를 정의할 수 없는 Functional 컴포넌트에서는 별도의 기능이 필요하다. React에서는 Functional 컴포넌트에서 ref를 통한 접근을 위해forwardRef()와 useImperativeHandle() 를 제공한다. [그림 08] useImperativeHandle과 forwardRef를 이용한 명령형 프로그래밍 forwardRef() 는 Functional 컴포넌트에 ref 속성을 이용할 수 있도록 하는 기능으로 해당 함수로 Wrapping 된 컴포넌트는 위와 같이 ref를 매개변수로 받을 수 있게 된다. React 내부 WorkTag를 확인하면 forwardRef()를 통해 생성된 컴포넌트는 일반 FunctionComponent 태그와 차별을 두는 ForwardRef 태그로 명시된다. [그림 09] React 내부적으로 동작을 구분하기 위해 사용하는 work tag. ForwardRef를 통한 컴포넌트를 분리함 useImperativeHandle()는 이름 처럼 Imperative(명령형) 동작에 대한 Handler를 제공한다. 즉, ref.current의 속성으로 접근할 수 있는 메소드에 대해 구현하는 부분이다. 이를 통해 부모 컴포넌트에서 자식 컴포넌트의 state를 조작할 수도 있고, 특정 애니메이션을 트리거 할 수도 있다. 결론 이 글을 통해 React에서 제공하는 ref 기능에 대해 다음과 같은 사실을 배울 수 있었다. 01. Ref는 DOM Element 객체나 React Component 인스턴스를 직접 조회할 수 있다. 02. useRef()나 createRef()는 current 속성을 가지는 Mutable Object를 반환한다. 03. Ref기능은 React의 기본 패러다임인 Declarative(선언형)이 아닌 Imperative(명령형) 패러다임의 기능이다. 이런 ref의 특성을 이용하면 특정 DOM의 API를 직접적으로 사용할 수 있고, 렌더링 없이 변경이 필요한 데이터를 관리할 수 있다. 또한, 자식의 state에 부모가 접근할 때나 state로 제어하지 않는 비제어 컴포넌트 를 사용할 때도 ref를 이용할 수 있다. React를 통해 개발을 진행하다 보면, state와 props 구조의 규칙을 지키면서 개발하기 어려운 요구 사항이 생길 수 있다. 이 글을 통해 그런 요구사항에 대해 "ref 기능을 이용한 색 다른 해결 방법이 있지 않을까?” 고민해 볼 수 있는 관점을 얻은 것 같다. 맺음말 처음 React Native로 앱 개발을 했을 때, 웹을 개발할 때 보다 ref를 많이 써서 당황한 적이 있다. 처음 React를 배울 때 ref는 비중이 높게 다뤄지지 않았기 때문에 자연스레 이 방법이 잘못된 것은 아닌지, 내가 잘 쓰고 있는지에 대한 고민을 많이 했다. React Native 라이브러리에는 네이티브 기능을 이용하기 위해 ref를 많이 쓴다. 예를 들면 FlatList 의 특정 항목으로 스크롤 이동을 할 때 사용한다. ref를 통한 조작이 익숙해질 때, 문득 “특정 UI 의 기능 명세가 확실하다면, useImperativeHandler 와 ForwardRef를 통해 UI의 동작 기능을 ref의 메소드로 관리하는 것이 컴포넌트의 모듈화에 더 유용하지 않을까?” 라는 생각이 들었다. 물론 이 방식이 React의 Declarative(선언형) 패러다임에 반하는 것이지만 패러다임에 고정된 생각보다는 사용성의 관점으로 고민이 되는 부분이었다. 혹시나 이 부분에 대한 이유나 혹은 이렇게 개발해 본 경험이 있는 React 개발자가 있다면, 댓글로 남겨주면 많은 사람들에게 도움이 될 것 같다. useRef useRef 는 단순 DOM 엘리먼트를 지정하는데만 사용되지 않는다. useRef 를 통해 클래스의 멤버 변수와 비슷한 역할을 하게 만들 수 있다. state 와 달리 값의 변화에 의한 리렌더링이 발생하지 않는다. current 라는 속성을 통해 어느 값이든 보유할 수 있는 일종의 컨테이너 역할을 할 수 있다. 함수형 컴포넌트는 인스턴스로 생성되지 않는다. 즉, 컴포넌트의 고유한 값을 저장할 방법이 없어 useRef를 통해 일종의 멤버변수를 구현하는 것. 다음의 코드는 ref 를 사용하여 state의 이전 값 을 보관하는 prevMathScore 라는 변수를 만든 예제이다. import React, { useState, useEffect, useRef } from "react";

function Score() { const [mathScore, setMathScore] = useState(40); const prevMathScore = useRef(40);

useEffect(() => { prevMathScore.current = mathScore; }, [mathScore]);

const result = prevMathScore.current < mathScore ? "올랐네요" : "개판이네요";

return ( <> <button onClick={() => setMathScore(mathScore + 20)}>시험보기 {성적이 ${result}!} </> ); }

요약해보자면, 1. state는 컴포넌트의 생명 주기와 밀접한 연관이 있는 요소이므로 렌더링과 관련 없는 값을 저장하기에는 적합치 않다. 2. ref는 setTimeout, setInterval이 반환하는 ID 값 state의 이전 값 이 외 렌더링과 무관한 가변값 위와 같이 렌더링과 관련이 없는 값을 저장하기에 적합하다.

---

출처:https://nukw0n-dev.tistory.com/14[찐이의 개발 연결구과]

https://kyounghwan01.github.io/blog/React/useRef-createRef/#%E1%84%92%E1%85%A1%E1%86%B7%E1%84%89%E1%85%AE%E1%84%92%E1%85%A7%E1%86%BC-%E1%84%8F%E1%85%A5%E1%86%B7%E1%84%91%E1%85%A9%E1%84%82%E1%85%A5%E1%86%AB%E1%84%90%E1%85%B3

]]> https://velog.io/@myungha_cho/%EB%B9%8C%EB%93%9C https://velog.io/@myungha_cho/%EB%B9%8C%EB%93%9C Sat, 21 May 2022 06:50:03 GMT 개발”빌드”배포

개발자 모드로 프로젝트를 만들면 용량이 무겁다.

• 성능 최적화
• 코드 난독화
• 특수 문법/라이브러리 지원(JSX, Typescript → VanilaJS)
• 호환성, 의존성 위해 브라우저마다 라이브러리/Js문법 downgrade(babel)

ex) Redactor Build된 파일

---

빌드 툴

‘주요(main)’ 모듈(‘진입점’ 역할을 하는 모듈)을 선택 ‘주요’ 모듈에 의존하고 있는 모듈 분석을 시작으로 모듈 간의 의존 관계를 파악 모듈 전체를 한데 모아 하나의 큰 파일을 생성 이런 과정 중에 변형이나 최적화도 함께 수행

• 도달 가능하지 않은 코드는 삭제됩니다.

• 내보내진 모듈 중 쓰임처가 없는 모듈을 삭제합니다(tree-shaking).

• console, debugger 같은 개발 관련 코드를 삭제합니다.

• 최신 자바스크립트 문법이 사용된 경우 바벨(Babel)을 사용해 동일한 기능을 하는 낮은 버전의 스크립트로 변환합니다.!

• 공백 제거, 변수 이름 줄이기 등으로 산출물의 크기를 줄입니다.

---

Webpack

소스 코드와 node_modules 폴더의 전체를 묶고, 빌드한 다음 브라우저에 제공 webpack-dev-server: hot-reloading 웹팩을 사용할 경우 코드를 조금만 수정하더라도 npm run dev 또는 npx webpack을 통해 다시 리로딩을 해야 하는 것이 불편함. 조금씩 수정한건 바로 반영, 데이터 보존

---

ESbuild

노드 기반 번들러보다 10~100배 빠름 create-react-app이 제공하는 옵션 제공 안 함 hot-reload제공 안 함

---

SnowPack

Snowpack 개발 서버는 node_modules의 각 의존성마다 하나의 자바스크립트 파일로 묶고 해당 파일을 기본 자바스크립트 모듈로 변환한 다음 브라우저에 제공한다. 브라우저는 이 스크립트를 캐시하고 스크립트가 변경된 경우에만 다시 요청할 수 있다.

Vite

Vite는 프로젝트의 모든 의존성을 단일 기본 자바스크립트 모듈로 사전 번들링을 진행한다. 그 후에 많은 캐시 된 HTTP 헤더와 함께 제공된다. 즉, 첫 페이지 로드 후 가져온 의존성을 컴파일, 제공 또는 요청하는 데 시간이 낭비되지 않는다. 또한 Vite는 명확한 에러 메시지들을 제공하고 문제를 해결하기 위해 정확한 코드 블록과 줄 번호를 보여준다.

WMR

Preact는 작고 가벼운 프로젝트를 수행하려는 경우에 좋다. hot-module-replacing 개발 서버와 최적화된 프로덕션 빌드를 포함, 별도의 구성이 필요 없으며 다운로드하는 데 몇 초밖에 걸리지 않는다.

---

참고문헌

• https://amkorousagi-money.tistory.com/entry/react-build
• https://ui.toast.com/weekly-pick/ko_20220127

]]> https://velog.io/@myungha_cho/Typescript-Clean-Code https://velog.io/@myungha_cho/Typescript-Clean-Code Sat, 21 May 2022 06:48:09 GMT Variables

1. 변수 이름은 구체적으로 Bad

   // 변수
   const AHCageId = 1
   

// 함수 const isBiggerThan = (a: number, b: number) => { return a > b }

Good

// 변수 const AdmissionHotelCageId = 1

// 함수 const isBiggerThan = (target: number, compareTarget: number) => { return a > b }

2. 유형이 같다면 동일 명칭으로
Bad

const getInitAData = () => {} const generateInitBData = () => {} const makeInitCData = () => {}

Good

const getInitAData = () => {} const getInitBData = () => {} const getInitCData = () => {}

// or

const generateInitAData = () => {} const generateInitBData = () => {} const generateInitCData = () => {}

// or

const makeInitAData = () => {} const makeInitBData = () => {} const makeInitCData = () => {}

3. 상수에도 의미 부여하기

Bad setTimeout(someFunc, 86400000)

// and

.my_className { position: relative; left: 270px; }

Good

const MILLISECONDS_IN_A_DAY = 24 * 60 * 60 * 1000 setTimeout(someFunc, MILLISECONDS_IN_A_DAY)

// and

.my_className { position: relative; left: calc(300px - 20px - 10px); } // padding, margin 등 계산한 값

4. Index 접근 하지 말기

Bad const userNameMap = new Map<number, string>()

for (const data of userNameMap){ const id = data[0] const name = data[1] } Good const userNameMap = new Map<number, string>()

for (const [id, name] of userNameMap){ // ... }

5. destructuring 쓰기
Bad

type Props = { onClose?: () => void pet?: GQLGetPet } export const PacsAddModal = (props: Props) => { ... }

Good

type Props = { onClose?: () => void pet?: GQLGetPet } export const PacsAddModal = ({ onClose, pet }: Props) => { ... }

6. 의미 중복 지양하기
Bad

type User = { userId: number userName: string }

Good

type User = { id: number name: string }

7. default value 쓰기(short circuiting)
Bad

const showPrettyName = (name?: string) => { return

{name ?? '2름'}

}

Good

const showPrettyName =(name?: string = '2름') => { return

{name}

}

8. undefined와 0 확실히 구분하기 (보통 number type)
Bad

export function isSafeNumberWithConstraints( value: number, options?: { minValue?: number maxValue?: number }, ) { // limit max if (options?.maxValue && value > options.maxValue) return false

// limit min if (options?.minValue && value < options.minValue) return false

return true }

Good

export function isSafeNumberWithConstraints( value: number, options?: { minValue?: number maxValue?: number }, ) { // limit max if (options?.maxValue !== undefined && value > options.maxValue) return false

// limit min if (options?.minValue !== undefined && value < options.minValue) return false

return true }

9. enum 및 switch 사용하기
Bad

type MyVar = { id: number status: number }

const myVar = { id: 1 status: 2 }

// ...

if (myVar.status === 1){ // ... } else if(myVar.status === 2){ // ... }

Good

enum EMyVarStatus { A = 1, B = 2, C = 3 }

type MyVar = { id: number status: EMyVarStatus }

const myVar = { id: 1 status: EMyVarStatus.B }

// ...

// 1 const a = new Map<MyEnum, string>([ [MyEnum.A, () => {}], [MyEnum.B, () => {}] ])

// 2 switch (myVar.status){ case EMyVarStatus.A: // ... case EMyVarStatus.B: // ... default: // ... }

Function
함수
1. 매개변수 3개 이상은 object로 (+destructuring)
Bad

const sumOfLengthOfRectangle = (width: number, height: number, depth: number) => { return width + height + depth }

Good

type RectangleSide = { width: number height: number depth: number }

const sumOfLengthOfRectangle = ({width, height, depth}: RectangleSide) => { return width + height + depth }

2. 함수 단일책임 시키기(SRP) (=== 선언형)
Bad

const emailClients = (clients: Client[]) => { clients.forEach((client) => { const clientRecord = database.lookup(client) if (clientRecord.isActive()) { email(client) } }); }

// or

const getChildrenAndGetSumOfAge = () => { const children = database.get('children')

return sumOf(children.map((child) => child.age)) }

Good

const emailClients = (clients: Client[]) => { clients.filter(isActiveClient).forEach(email) }

function isActiveClient(client: Client) { const clientRecord = database.lookup(client) return clientRecord.isActive() }

// or

const getTotalAgeOfChildren = () => { return sumOf(getChildrenAges()) }

const getChildrenAges = () => { return database.get('children').map((child) => child.age) }

3. 코드 중복 제거하기
설명 귀찮음

4. 함수 인자에 _(underscore) 붙이기
Bad

const someFunc = (child: Child, age: number) => { // ... }

// or

const childrenAges = myChildren.map((child) => { return child.age })

Good

const someFunc = (_child: Child, _age: number) => { // ... }

// or

const childrenAges = myChildren.map((_child) => { return _child.age }) ⇒ 항상은 아니다.

Bad

const someFunc = ({_child, _age}: {_child: Child, _age: number}) => { // ... }

// or

const someFunc = ({_child: child, _age: age} : {_child: Child, _age: number}) => { // ... }

Good

const someFunc = ({child, age}: {child: Child, age: number}) => { // ... }

5. 함수 인자로 플래그처럼 쓰지 말기
Bad

const createFile = (name: string, temp: boolean) => { if (temp) { fs.create(./temp/${name}) } else { fs.create(name) } }

Good

const createTempFile = (name: string) => { createFile(./temp/${name}) }

const createFile = (name: string) => { fs.create(name) } ⇒ 하지만 이벤트 자체가 명확하지 않으면, 플래그 구분이 어딘가에는 결국 들어간다.

(이벤트 자체가 명확한 경우)

Bad

const handleButtonClick = (_myVar?: number) => () => { if(_myVar !== undefined){ console.log(_myVar) }else{ console.log('no!') } }

// ...

<button onClick={handleButtonClick(5)}

버튼1

<button onClick={handleButtonClick()}

버튼2 Good const handleNumberButtonClick = (_myVar: number) => () => { console.log(_myVar) }

const handleButtonClick = () => { console.log('no!') }

// ...

<button onClick={handleNumberButtonClick(5)}

버튼1

<button onClick={handleButtonClick}

버튼2

6. Side Effect 피하기(순수 함수) 1
Bad

export const SomeComponent = ({someA, someB}: Props) => { const [count, setCount] = useState(0)

const processSomething = () => { console.log(count, someA) }

const handleButtonClick = () => { processSomething() }

return ( ... ) }

Good

export const SomeComponent = ({someA, someB}: Props) => { const [count, setCount] = useState(0)

const processSomething = (_count: number, _someA: number) => { console.log(_count, _someA) }

const handleButtonClick = () => { processSomething(count, someA) }

return ( ... ) }

⇒ React 이벤트 핸들러에는 굳이..?

React에서 완벽한 순수함수를 하려면?

export const SomeComponent = ({someA, someB}: Props) => { const [count, setCount] = useState(0)

const processSomething = (_count: number, _someA: number) => { console.log(_count, _someA) }

const handleButtonClick = (_count: number, _someA: number) => () => { processSomething(_count, _someA) }

// 어차피 props 써야함 return ( <button onClick={handleButtonClick(count, someA)}>{...} ) }

7. Side Effect 피하기(순수 함수) 2
Bad

const addItemToCart = (cart: CartItem[], item: Item): void => { cart.push({ item, date: Date.now() }) }

Good

const addItemToCart = (cart: CartItem[], item: Item): CartItem[] => { return cart.concat({ item, date: Date.now() }) }

8. Immutable에 적극 활용하기
Bad

let order = 0

if (condition1){ order = 3 }else if(condition2){ order = 1 }

console.log(order)

Good

const getOrderByCondition = () => { if (condition1){ return 3 } else if (condition2){ return 1 }

return 0

}

const order = getOrderByCondition() console.log(order)

9. 조건문 캡슐화 (선언형)
Bad

if (subscription.isTrial || account.balance > 0) { // ... }

Good

const canActivateService = (_subscription: Subscription, _account: Account) => { return _subscription.isTrial || _account.balance > 0 }

if (canActivateService(subscription, account)) { // ... }

10. 부정 조건문 피하기
Bad

const isEmailNotUsed = (email: string): boolean => { // ... }

if (isEmailNotUsed(email)) { // ... }

Good

const isEmailUsed = (email): boolean => { // ... }

if (!isEmailUsed(node)) { // ... }

11. 과한 최적화는 피하기
Bad

const length = myList.length for (let i = 0; i < length; i++ ) { ... }

Good

for (let i = 0; i < myList.length; i++ ) { ... }

```

]]> https://velog.io/@myungha_cho/%EB%B6%84%EC%82%B0%EC%BB%B4%ED%93%A8%ED%8C%85%EB%B6%84%EC%82%B0%ED%8C%8C%EC%9D%BC%EC%A0%80%EC%9E%A5 https://velog.io/@myungha_cho/%EB%B6%84%EC%82%B0%EC%BB%B4%ED%93%A8%ED%8C%85%EB%B6%84%EC%82%B0%ED%8C%8C%EC%9D%BC%EC%A0%80%EC%9E%A5 Sat, 21 May 2022 06:34:09 GMT

P2P

BlockChain

IPFS

클라우스 환경에서의 분산컴퓨팅

]]> https://velog.io/@myungha_cho/Substrate-tutorial4 https://velog.io/@myungha_cho/Substrate-tutorial4 Tue, 17 May 2022 04:15:20 GMT This materials was written based on https://docs.substrate.io/tutorials/v3/kitties/pt1/

git clone https://github.com/chomyungha51/substrate-kitties-node.git

I left numbered comment for you not to switching windows between ppt and tutorial page:) Just uncomment it one by one!

Get substrate-front-end-template

git clone https://github.com/chomyungha51/substrate-kitties-front-template.git cd substrate-kitties-front-template yarn install

2. In a separate terminal, start an instance of node-kitties that you built in Part I

./target/release/node-kitties --dev --tmp

3. Start the Front-end template

yarn start

https://docs.google.com/presentation/d/1zO5wb8omIb5n7_MnrU4BIbFJqlCuf_6gXEFeE4aQ_SY/edit?usp=sharing

]]> https://velog.io/@myungha_cho/Subscription-%EC%BF%BC%EB%A6%AC-%EC%B5%9C%EC%A0%81%ED%99%94 https://velog.io/@myungha_cho/Subscription-%EC%BF%BC%EB%A6%AC-%EC%B5%9C%EC%A0%81%ED%99%94 Wed, 11 May 2022 01:21:21 GMT HTTP

http는 요청-응답 기반의 프로토콜

• 연결: 3way-handshaking
• 종료: 4way-handshaking

keep-alive : 설정한 시간 동안 계속해서 네트워크가 연결

실시간으로 데이터를 받고 싶을 땐?

• http polling

서버로 일정 주기 요청 데이터가 사용가능하거나 타임아웃인 경우에 응답 서버가 처리해야 하는 요청이 너무 많음

• http streaming

서버에 요청을 보내고 끊기지 않은 연결상태에서 끊임없이 데이터를 수신 클라이언트에서 서버로의 데이터 송신이 어려움 중간에 연결 끊기면 실시간 보장 못 함

---

WEBSOCKET

서버와 클라이언트 간에 Socket Connection을 유지해서 양방향 통신 이벤트 유도 프로토콜

• Http 포트번호 80(ws) 또는 443(wss) 위에서 동작
• 업그레이드 헤더를 사용해 http에서 websocket으로 변경

연결 과정

• 요청

HTTP 1.1로 요청 웹 소켓 프로토콜로 업그레이드 요청 소켓 버전과 소켓 비밀키 정보 등을 포함

• 응답

HTTP status 101 응답 일정 시간이 지나면 HTTP연결은 자동으로 끊어진다.

데이터 전송 frame

• 헤더 + payload로 구성
• UTF-8 인코딩

800byte에서 수 kbyte의 헤더 크기를 가지고 있는 HTTP와 달리 WebSocket은 수 byte 수준으로 압축이 가능

고려할 점

• 이벤트 유실(유저의 네트워크 환경) : 브로드캐스팅
• 연결이 끊기면 다시 알아서 연결 안 됨 서버 다운/연결 끊길 경우 대비한 로직
• 데이터 파싱: WebSocket은 주고 받는 데이터의 해독은 온전히 어플리케이션에 맡김, sub-protocols을 사용

---

최적화

1. 페이지네이션

2. 레이지로딩

3. image/jpeg => image/webp :webp는 JPG, PNG와 같이 이미지 포맷 형식 중 하나, 최고의 이미지 압축률

4. gzip같은 방식으로 이미지 압축해서 전송 : Accept-Encoding은 클라이언트 단에서 받아들일 수 있는 압축 방식, gzip은 콘텐츠 압축에 있어 원본 데이터 약 70%를 압축

5. Native reversed loop로 변경

6. setTimeout으로 부하가 큰 로직을 큐로 넘기기

7. 연결 빈도 수 제한 메모리는 웹소켓을 통한 SEND 커맨드 같이 서버가 서비스 관련 메시지를 보낼 때 보다 SUBSCRIBE/UNSUBSCRIBE(이하 SUB/UNSUB)시 더 많이 사용됨 SUB/UNSUB가 자주 일어나게 되면 처리 속도가 밀림 최대 SUB/UNSUB 빈도 수를 2800TPS로 설정 적절함의 기준은 GC가 발생했을 때 요청 처리 속도가 현저하게 느려지지 않는 수준

8. Vanila JS 리팩토링

컴포넌트가 재활용성이 필요한 페이지나 동적 처리가 많은 스크립트 코드를 제외하곤, 기본적인 랜딩 페이지나 기본 동작 스크립트, 라이브러리들은 모두 리액트를 걷어내고 바닐라(Vanilla) 자바스크립트로 변경하여 위와 같은 성과를 얻을 수 있었다고 함

---

참고 문헌

https://velog.io/@wldus9503/%EB%84%A4%ED%8A%B8%EC%9B%8C%ED%81%AC-Network3.-WebSocket-%EC%9B%B9-%EC%86%8C%EC%BC%93%EC%97%90-%EB%8C%80%ED%95%B4%EC%84%9C https://velog.io/@oyeon/%EC%9B%B9-%EC%86%8C%EC%BC%93WebSocket https://www.peterkimzz.com/websocket-vs-socket-io/ https://helloinyong.tistory.com/295

]]> https://velog.io/@myungha_cho/%EB%A1%9C%EA%B7%B8%EC%9D%B8%EC%A0%88%EC%B0%A820220421 https://velog.io/@myungha_cho/%EB%A1%9C%EA%B7%B8%EC%9D%B8%EC%A0%88%EC%B0%A820220421 Wed, 11 May 2022 00:12:40 GMT 로그인 로그인을 하는 이유? : 매 요청마다 아이디와 비밀번호를 전송(쿼리, 아이디와 비밀번호 노출 횟수 증가)하지 않고 사용자 정보(접근권한) 유지

사용자가 입력한 비밀번호 암호화 아이디와 비밀번호 해시값 데이터베이스에서 탐색 세션 기반 인증 : 서버가 관리

발급 서버 쪽 저장소에 세션 생성(key: 세션ID - value: 사용자 정보) 세션ID를 클라이언트에게 응답

사용 클라이언트는 서버에 요청할 때마다 세션ID도 전송 서버는 세션 ID로 사용자 식별

삭제 로그아웃하면, 서버는 해당 세션 삭제

장점 서버 보안이 (클라이언트보다) 더 좋고 세션 관리가 가능

단점 사용자들이 동시에 많이 접속하면 서버 저장소에 부하 저장소에 문제가 생겨서 세션들이 전부 날아가면, 로그인한 사용자들은 전부 다시 로그인해야 함 여러 대의 서버들로 운영되는 경우 세션을 공용 저장소에 저장해야 함

토큰 기반 인증 : 클라이언트가 관리

발급 서버가 사용자 정보와 비밀 키를 이용하여 토큰을 발급하고 클라이언트에게 응답 클라이언트 단의 저장소(쿠키, 로컬 스토리지, 세션 스토리지)에 저장

사용 클라이언트는 요청을 보낼 때마다 해당 토큰을 서버에 전송 서버는 토큰으로 사용자 식별

삭제 로그아웃하면, 클라이언트 저장소에서 해당 토큰 삭제

장점 서버 쪽 저장소의 부하를 신경 쓸 필요 없음

단점 토큰 자체에 로그인한 사용자의 상태 정보가 담겨 있음 한 번 발급한 토큰을 유효기간 지나기 전까지 무효화시킬 방법이 없음 -> 해킹당했을 때 피해 더 큼

JWT(JSON Web Token) 토큰 기반 인증에서 사용하는 대표적인 토큰

헤더(Header) 페이로드(Payload) 서명(Signature) 각 부분을 Base64로 인코딩하고 이들을 마침표(.)를 이용하여 차례대로 연결 빨간색 부분이 헤더, 보라색 부분이 페이로드, 하늘색 부분이 서명

헤더 (Header) 토큰의 타입 ex) 'JWT' 서명 계산 및 토큰 검증에 사용할 암호화 알고리즘 ex) HS256(SHA256), RSA 페이로드 (Payload) 로그인한 사용자의 상태 정보 ex) 누가 누구에게 발급한 토큰인지, 유효 기한, 사용자에게 공개하고자 하는 정보들은 무엇인지 등 서명 (Signature) : 토큰의 무결성, 유효성을 검증하는 데 사용 (헤더와 페이로드를 Base64로 인코딩하고, 이 둘을 마침표(.)로 연결한 것을 서버의 비밀 키와 함께 암호화 알고리즘에 넣어서 얻은 값)

서버는 받은 토큰의 헤더와 페이로드로 서명 값을 계산하고, 계산해서 얻은 값과 받은 토큰에 있는 서명 필드가 동일한지 검사(무결성) 만약 동일하지 않다면 요청을 거부하고, 동일하다면 유효 기한을 검사 단점 JWT의 페이로드를 Base64로 디코딩만 하면 해당 사용자의 정보를 손쉽게 얻어낼 수 있음 이미 발급된 JWT는 무효화를 하기가 어려움 -> 한 번 해킹당하면 유효기간 끝날 때까지 못 막음

리프레시 토큰 로그인에 성공하면, 두 개의 토큰을 발급

액세스 토큰: 사용자의 상태 정보 저장하는 토큰 리프레시 토큰: 액세스 토큰을 다시 발급받기 위해 서버에 전송하는 토큰

액세스 토큰의 유효 기간을 짧게 유지(해커가 오래 쓰지 못하도록) 로그인한 사용자의 상태 정보를 서버가 관리 가능 동시 로그인 관리 가능: 동일한 리프레시 토큰을 공유 토큰을 어디에 저장할까? (session storage -> 브라우저 종료 시 초기화)

local storage -> 반영구적 cookie -> 브라우저에서 자동으로 보내는 값, 해커 코드 자동으로 실행되는 경우 : CSRF

db : refresh token에 대한 hash table 참고문헌

https://it-eldorado.tistory.com/164 https://it-eldorado.tistory.com/165 https://blog.lgcns.com/2687 https://programming-workspace.tistory.com/51

]]> https://velog.io/@myungha_cho/SubstrateKitties-2 https://velog.io/@myungha_cho/SubstrateKitties-2 Tue, 10 May 2022 05:09:00 GMT part 2

우리의 고양이 노드와 소통할 수 있는 커스텀 리액트 컴포넌트 만들기

1. 시작하기

Substrate Front-end Template 설치하기

git clone https://github.com/substrate-developer-hub/substrate-front-end-template.git cd substrate-front-end-template yarn install

폴더구조 substrate-front-end-template | +-- public | | | +-- assets <-- Kitty avatar PNG files | +-- src <-- our React components | | | +-- tests | | | +-- config <-- where to specify our custom types | | | +-- substrate-lib <-- lib to give access to PolkadotJS API | | | | | +-- components <-- contains TxButton, used throughout our application | | | ... ...

다른 터미널을 열어서 Part1에서 만든 노드 시작하기

Launch node-kitties from its directory.

cd kitties/ ./target/release/node-kitties --dev --tmp

프론트엔드 디렉토리로 돌아와서, 시작하기 yarn start

무엇을 만들까? Substrate Front-end template은 폴카닷JS API와 RPC엔드포인트를 사용해 Substrate노드와 소통 그래서 스토리지 아이템도 읽고 dispatchable 함수를 호출해 extrinsic을 만들 수도 있음

1. Kitties.js
2. KittyCards.js
3. KittyAvatar.js

** 폴카닷 JS API 기초 공부하기 Basics and Metadata RPC queries Storage methods Extrinsics methods The Devhub substrate-frontend-template

2. 커스컴 컴포넌트 만들기

Kitties.js만들기 가장 top-level에 있는 컴포넌트로, Apps.js에 의해 렌더링될 것

src폴더에 Kitties.js파일 만들고 임포트

import React, { useEffect, useState } from 'react' import { Form, Grid } from 'semantic-ui-react'

import { useSubstrateState } from './substrate-lib' import { TxButton } from './substrate-lib/components'

import KittyCards from './KittyCards'

폴카닷 JS API 인스턴스의 래퍼인 substrate-lib를 통해서 폴카닷 JS API를 사용할 것 계정 키를 가져올 수도 있음

const parseKitty = ({ dna, price, gender, owner }) => ({ dna, price: price.toJSON(), gender: gender.toJSON(), owner: owner.toJSON(), })

export default function Kitties(props) { const { api, keyring } = useSubstrateState() const [kittyIds, setKittyIds] = useState([]) const [kitties, setKitties] = useState([]) const [status, setStatus] = useState('')

parseKittiy() : 고양이 데이터를 가지고 있고 오브젝트를 리턴하는 함수 Kitties : 체인의 스토리지 아이템이 실시간으로 변하는 걸 감지하고 useEffect를 써서 우리의 다른 컴포넌트의 상태를 업데이트시켜줌

실시간으로 변화를 감지해야 하는 건

• 고양이 양에 대한 스토리지 변화
• 고양이 오브젝트의 변화

각각 subscription 함수를 만들 것임

• 고양이 양: 우리의 고양이 팔레트 스토리지 아이템에 CountForKitties에 쿼리 날리는 api.query.substrateKitties.countForKitties를 쓸 것
• 모든 고양이 데이터를 api.query.substrateKitties.kitties메소드로 가져오고 parseKittiy()함수로 파싱할 것

// Subscription function for kitty count const subscribeCount = () => { let unsub = null const asyncFetch = async () => { unsub = await api.query.substrateKitties.countForKitties( async count => { // Fetch all kitty keys const entries = await api.query.substrateKitties.kitties.entries() const ids = entries.map(entry => entry[1].unwrap().dna) setKittyIds(ids) } ) } asyncFetch() return () => { unsub && unsub() } }

// Subscription function to construct all kitty objects const subscribeKitties = () => { let unsub = null const asyncFetch = async () => { unsub = await api.query.substrateKitties.kitties.multi( kittyIds, kitties => { const kittiesMap = kitties.map(kitty => parseKitty(kitty.unwrap())) setKitties(kittiesMap) } ) } asyncFetch() return () => { // return the unsubscription cleanup function unsub && unsub() } }

asyncFetch에서 고양이 스토리지를 구독했다. 이 컴포넌트가 끝날 때, 구독 취소를 하고 싶다. 그래서 리턴함수로 정리해줌

리액트의 useEffect()로 subscribeCount와 subscribeKitties를 넘겨주면 됨

useEffect(subscribeCount, [api, keyring]) useEffect(subscribeKitties, [api, keyring, kittyIds])

2. src/KittyAvatar.js 고양이의 DNA와 PNG이미지를 맵핑시킬 것

import React from 'react'

// Generate an array [start, start + 1, ..., end] inclusively const genArray = (start, end) => Array.from(Array(end - start + 1).keys()).map(v => v + start)

const IMAGES = { accessory: genArray(1, 20).map( n => ${process.env.PUBLIC_URL}/assets/KittyAvatar/accessorie_${n}.png ), body: genArray(1, 15).map( n => ${process.env.PUBLIC_URL}/assets/KittyAvatar/body_${n}.png ), eyes: genArray(1, 15).map( n => ${process.env.PUBLIC_URL}/assets/KittyAvatar/eyes_${n}.png ), mouth: genArray(1, 10).map( n => ${process.env.PUBLIC_URL}/assets/KittyAvatar/mouth_${n}.png ), fur: genArray(1, 10).map( n => ${process.env.PUBLIC_URL}/assets/KittyAvatar/fur_${n}.png ), }

const dnaToAttributes = dna => { const attribute = (index, type) => IMAGES[type][dna[index] % IMAGES[type].length]

return { body: attribute(0, 'body'), eyes: attribute(1, 'eyes'), accessory: attribute(2, 'accessory'), fur: attribute(3, 'fur'), mouth: attribute(4, 'mouth'), } }

const KittyAvatar = props => { const outerStyle = { height: '160px', position: 'relative', width: '50%' } const innerStyle = { height: '150px', position: 'absolute', top: '3%', left: '50%', } const { dna } = props

if (!dna) return null

const cat = dnaToAttributes(dna) return (

) }

export default KittyAvatar

KittyCards.js로부터 dna 하나만 전달받음

링크에 가서 PNG다운받고 public/assets/KittyAvatar라는 새 폴더를 만들어서 PNG들 붙여넣기

3. KittyCards.js 안에 transferModal 작성하기 KittyCards는 세 파트로 나눠질 것임

• TransferModal, setPrice, buyPrice : TxButton컴포넌트를 사용한 모달 다이얼로그
• KittyCard : KittyAvatar컴포넌트를 사용해서 고양이 아바타를 보여주는 카드
• KittyCards : KittyCard를 그리드로 보여주는 컴ㅍ넌트

먼저 src/KittyCards.js를 만들고 임포트

import React from 'react' import { Button, Card, Grid, Message, Modal, Form, Label, } from 'semantic-ui-react' import KittyAvatar from './KittyAvatar' import { useSubstrateState } from './substrate-lib' import { TxButton } from './substrate-lib/components'

먼저 TransferModal을 보자

Substrate Front-end Template이 TxButton이라는 컴포넌트를 갖고 있는데 노드와 상호작용하는 전송 버튼을 포함하는 유용한 방법이다

노드에 트랜잭션을 보내고 고양이 팔레트에 서명된 extrinsic을 유발하도록 해줌

transfer button modal(kitty id, receiver address) transfer, cancel button

세 파트로 구성됨

나머지도 비슷한 구성임

리액트 훅으로 props 추출하기 const TransferModal = props => { const { kitty, accountPair, setStatus } = props; const [open, setOpen] = React.useState(false); const [formValue, setFormValue] = React.useState({}); const formChange = key => (ev, el) => { setFormValue({ ...formValue, [key]: el.value }); }; const confirmAndClose = unsub => { setOpen(false) if (unsub && typeof unsub === 'function') unsub() } return ( <Modal onClose={() => setOpen(false)} onOpen={() => setOpen(true)} open={open} trigger={ Transfer }

<Modal.Header>Kitty Transfer</Modal.Header>
<Modal.Content>
  <Form>
    <Form.Input fluid label="Kitty ID" readOnly value={kitty.dna} />
    <Form.Input
      fluid
      label="Receiver"
      placeholder="Receiver Address"
      onChange={formChange('target')}
    />
  </Form>
</Modal.Content>
<Modal.Actions>
  <Button basic color="grey" onClick={() => setOpen(false)}>
    Cancel
  </Button>
  <TxButton
    label="Transfer"
    type="SIGNED-TX"
    setStatus={setStatus}
    onClick={confirmAndClose}
    attrs={{
      palletRpc: 'substrateKitties',
      callable: 'transfer',
      inputParams: [formValue.target, kitty.dna],
      paramFields: [true, true],
    }}
  />
</Modal.Actions>

)

4. KittyCard 작성하기 Kitty.js로부터 받은 props로 컴포넌트 렌더링

Semantic UI Card컴포넌트 사용할 것임

// Use props const KittyCard = props => { const { kitty, setStatus } = props const { dna = null, owner = null, gender = null, price = null } = kitty const displayDna = dna && dna.toJSON() const { currentAccount } = useSubstrateState() const isSelf = currentAccount.address === kitty.owner

return ( {isSelf && ( Mine )} {/* Render the Kitty Avatar /} <Card.Content> {/ Display the Kitty DNA /} <Card.Meta style={{ fontSize: '.9em', overflowWrap: 'break-word' }}> DNA: {displayDna} </Card.Meta> {/ Display the Kitty Gender, Owner, and Price */} <Card.Description> <p style={{ overflowWrap: 'break-word' }}>Gender: {gender}

<p style={{ overflowWrap: 'break-word' }}>Owner: {owner}

<p style={{ overflowWrap: 'break-word' }}> Price: {price || 'Not For Sale'}

</Card.Description> </Card.Content> <Card.Content extra style={{ textAlign: 'center' }}> {owner === currentAccount.address ? ( <> </> ) : ( <> </> )} </Card.Content> } 주인이 옮기는 경우에만 Transfer Modal과 SetPRice 컴포넌트가 뜨도록 해줌

5. KittyCards 쓰기

• 하나도 없으면 하나도 없으니까 하나 만들라는 메시지 보여주기
• 있으면 3열로 보여주기

const KittyCards = props => { const { kitties, setStatus } = props

if (kitties.length === 0) { return ( <Message.Header> No Kitty found here... Create one now!  👇 </Message.Header> ) }

return ( {kitties.map((kitty, i) => ( <Grid.Column key={kitty-${i}}> </Grid.Column> ))} ) } export default KittyCards

SetPrice와 BuyKitty는 안 다룰것임 솔루션 봐라

6. Kitties.js로 돌아와서 완성하기

return <Grid.Column width={16}>

Kitties

이거 복붙하고 : Grid안에 KittyCard 컴포넌트 넣음

{status}

; }

이거도 복붇하고 : TxButton 컴포넌트 렌더링하기 위해 form 사용

7. App.js 업데이트

임포트문 추가 import Kitties from './Kitties'

Container에 다음 줄 추가 <Grid.Row> </Grid.Row>

전체 정답 코드 https://github.com/substrate-developer-hub/substrate-front-end-template/blob/tutorials%2Fsolutions%2Fkitties/src/KittyCards.js

]]> https://velog.io/@myungha_cho/%ED%8A%9C%ED%86%A0%EB%A6%AC%EC%96%BC4-Substrate-Kitties1 https://velog.io/@myungha_cho/%ED%8A%9C%ED%86%A0%EB%A6%AC%EC%96%BC4-Substrate-Kitties1 Mon, 09 May 2022 14:25:45 GMT 러스트 코드 많다그래서 공부할 겸 이 파트 한다했는데...... 파트 1, 2로 나눌 정도로 분량 많을 줄이야...... 허허허

---

Substrate Kitties 체인 만들기

이 튜토리얼에서 Substrate kitties라 불리는 NFT를 생성하고 소유권을 다루는 블록체인을 만드는 법을 배울 겁니다.

파트 1에서는 당신이 만든 키티들과 상호작용할 수 있는 기능을 포함해서 키티 팔레트를 만드는 방법을 다룹니다.

파트 2에서는 파트 1에서 만든 Substarte Kitties 블록체인과 상호작용하도록 프론트엔드를 개발하는 방법을 다룹니다.

1. 튜토리얼 목표

• Substrate 노드를 만들고 실행시키는 기본 패턴을 배운다
• 커스텀 FRAME 팔렛을 작성하고 런타임에 통합한다.
• 스토리지 아이템들을 만들고 업데이트하는 법을 배운다
• pallet extrinsic과 helper function을 작성한다
• Substrate 노드를 커스텀 프론트엔드와 연결하기 위해 폴카닷JS API를 사용한다

시작하기 전에 설치할 것 참고

우리가 만드는 것

• 기존의 소스로부터 만들어지거나 기존 키티들을 길러서 생성
• 주인에 의해 설정된 가격에 팔림
• 주인에게서 다른 주인에게로 전송

우리가 다루지 않는 것

• 팔레트 테스트 코드
• 정확한 무게 값 사용하기

2. 기본 세팅

커스텀 팔렛을 설정하고 간단한 스토리지 아이템을 포함하는 섭스트레이트 노드 템플릿을 사용하는 기본적인 패턴을 다룹니다.

당신의 템플릿 노드 설정하기 섭스트레이트 노드 템플릿에 네트워킹과 합희 계층이 포함되어 있기 때문에, 런타임과 팔렛의 로직을 만드는 것에만 집중하면 됩니다.

시작하기 위해서, 우리는 프로젝트 이름과 의존성을 설정해야 합니다. kickstart라는 CLI 도구로 쉽게 노드템플릿의 이름을 바꾸겠습니다.

1. cargo install kickstart

2. 프로젝트를 시작하고 싶은 루트 디렉토리에서 kickstart https://github.com/sacha-l/kickstart-substrate : 제일 최근의 노드 템플릿 복사본을 클론해오고 노드와 팔레트 이름 설정하게 함

3. kitties(node 폴더 안에 생김), kitties(pallet 폴더 안에 생김)

4. 좋아하는 IDE로 kitties 디렉토리를 열고 이름을 kitties-tutorial로 바꿈 kickstart가 수정한 디렉토리들

• node : 당신의 노드가 런타임과 RPC 클라이언트들과 상호작용하는 걸 허용하는 모든 로직을 포함
• pallets : 모든 커스텀 팔렛들이 있음
• runtime : 모든 팔렛들이 집계되고 체인의 런타임에서 구현됨

5.runtime/src/lib.rs에서 커스텀 팔렛의 이름을 TemplateModule에서 SubstrateKitties로 수정

construct_runtime!(
    // --snip
    {
        // --snip
        SubstrateKitties: pallet_kitties,
    }
);

pallet_kitties의 발판 작성

kitties-tutorial <-- The name of our project directory | +-- node | +-- pallets | | | +-- kitties | | | +-- Cargo.toml | | | +-- src | | | +-- benchmarking.rs <-- Remove file | | | +-- lib.rs <-- Remove contents | | | +-- mock.rs <-- Remove file | | | +-- tests.rs <-- Remove file | +-- Cargo.toml

1. pallets/kitties/src에 있는 benchmarking.rs, mock.rs, test.rs를 삭제하고 lib.rs의 내용을 지우기

섭스트레이트에서 팔렛은 런타임 로직을 정의하는 데 사용되고, 우리는 섭스트레이트 키티들을 관리하는 모든 로직을 하나의 팔렛에 만들 것

모든 FRAME 팔렛은

• frame_support와 frame_system의 의존성 집합
• 필요한 attribute macros(configuration trait, storage item, function call...) 를 가짐

1. pallet/kitties/src/lib.rs 파일의 내용을 다음 코드로 교체

#![cfg_attr(not(feature = "std"), no_std)]

pub use pallet::*;

#[frame_support::pallet]
pub mod pallet {
    use frame_support::{
        sp_runtime::traits::{Hash, Zero},
        dispatch::{DispatchResultWithPostInfo, DispatchResult},
        traits::{Currency, ExistenceRequirement, Randomness},
        pallet_prelude::*
    };
    use frame_system::pallet_prelude::*;
    use sp_io::hashing::blake2_128;

    // TODO Part II: Struct for holding Kitty information.

    // TODO Part II: Enum and implementation to handle Gender type in Kitty struct.

    #[pallet::pallet]
    #[pallet::generate_store(pub(super) trait Store)]
    pub struct Pallet<T>(_);

    /// Configure the pallet by specifying the parameters and types it depends on.
    #[pallet::config]
    pub trait Config: frame_system::Config {
        /// Because this pallet emits events, it depends on the runtime's definition of an event.
        type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;

        /// The Currency handler for the Kitties pallet.
        type Currency: Currency<Self::AccountId>;

        // TODO Part II: Specify the custom types for our runtime.

    }

    // Errors.
    #[pallet::error]
    pub enum Error<T> {
        // TODO Part III
    }

    #[pallet::event]
    #[pallet::generate_deposit(pub(super) fn deposit_event)]
    pub enum Event<T: Config> {
        // TODO Part III
    }

    // ACTION: Storage item to keep a count of all existing Kitties.

    // TODO Part II: Remaining storage items.

    // TODO Part III: Our pallet's genesis configuration.

    #[pallet::call]
    impl<T: Config> Pallet<T> {

        // TODO Part III: create_kitty

        // TODO Part III: set_price

        // TODO Part III: transfer

        // TODO Part III: buy_kitty

        // TODO Part III: breed_kitty
    }

    // TODO Part II: helper function for Kitty struct

    impl<T: Config> Pallet<T> {
        // TODO Part III: helper functions for dispatchable functions

        // TODO: increment_nonce, random_hash, mint, transfer_from

    }
}

2. 우리의 팔렛에서 sp_io를 사용할 것이므로 Cargo.toml파일의 의존성에 이것이 추가되어있는지 확인

sp-io = { default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.20" }

3. 다음 커맨드로 팔렛 빌드해보기. 아직 Currency type을 구현하기 않았기 때문에 전체 체인은 빌드하지 않을 거임. 대신 팔렛의 에러가 있는지 없는지 확인하게 위해 빌드, unused import 에러는 무시해도 됨

cargo build -p pallet-kitties

storage item 추가

우리의 런타임에 변수를 저장하는 함수 로직을 추가해보자

storage macro에 의존하는 trait인 섭스트레이트 storage API에 있는 StorageValue를 사용할 것 우리가 선언하고 싶은 어떤 스토리지 아이템에 대해서 우리는 #[pallet::storage] 매크로를 먼저 써줘야 함

pallet/kitties/src/lib.rs 파일에서 Action 부분을 다음으로 교체

#[pallet::storage]
#[pallet::getter(fn count_for_kitties)]
pub(super) type CountForKitties<T: Config> = StorageValue<_, u64, ValueQuery>;

: 이것으로 총 존재하는 키티들의 개수를 우리의 팔렛에 추적하기 위한 스토리지 아이템을 생성

currency 구현 추가

우리의 노드를 만들기 전에, currency type을 팔렛 런타임 구현에 추가해야 함

runtime/src/lib.rs 에 다음 부분을 추가

impl pallet_kitties::Config for Runtime {
    type Event = Event;
    type Currency = Balances; // <-- Add this line
}

이제 진짜로 노드를 빌드하고 에러가 없는지 확인하기 cargo build --release

3. 유일성, 커스텀 타입, 스토리지 맵

pallet/kitties/src/lib.rs 파일을 다음 코드로 교체

#![cfg_attr(not(feature = "std"), no_std)]

pub use pallet::*;

#[frame_support::pallet]
pub mod pallet {
    use frame_support::pallet_prelude::*;
    use frame_system::pallet_prelude::*;
    use frame_support::{
        sp_runtime::traits::Hash,
        traits::{ Randomness, Currency, tokens::ExistenceRequirement },
        transactional
    };
    use sp_io::hashing::blake2_128;

    #[cfg(feature = "std")]
    use frame_support::serde::{Deserialize, Serialize};

    // ACTION #1: Write a Struct to hold Kitty information.

    // ACTION #2: Enum declaration for Gender.

    // ACTION #3: Implementation to handle Gender type in Kitty struct.

    #[pallet::pallet]
    #[pallet::generate_store(pub(super) trait Store)]
    pub struct Pallet<T>(_);

    /// Configure the pallet by specifying the parameters and types it depends on.
    #[pallet::config]
    pub trait Config: frame_system::Config {
        /// Because this pallet emits events, it depends on the runtime's definition of an event.
        type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;

        /// The Currency handler for the Kitties pallet.
        type Currency: Currency<Self::AccountId>;

        // ACTION #5: Specify the type for Randomness we want to specify for runtime.

        // ACTION #9: Add MaxKittyOwned constant
    }

    // Errors.
    #[pallet::error]
    pub enum Error<T> {
        // TODO Part III
    }

    // Events.
    #[pallet::event]
    #[pallet::generate_deposit(pub(super) fn deposit_event)]
    pub enum Event<T: Config> {
        // TODO Part III
    }

    #[pallet::storage]
    #[pallet::getter(fn count_for_kitties)]
    pub(super) type CountForKitties<T: Config> = StorageValue<_, u64, ValueQuery>;

    // ACTION #7: Remaining storage items.

    // TODO Part IV: Our pallet's genesis configuration.

    #[pallet::call]
    impl<T: Config> Pallet<T> {

        // TODO Part III: create_kitty

        // TODO Part IV: set_price

        // TODO Part IV: transfer

        // TODO Part IV: buy_kitty

        // TODO Part IV: breed_kitty
    }

    //** Our helper functions.**//

    impl<T: Config> Pallet<T> {

        // ACTION #4: helper function for Kitty struct

        // TODO Part III: helper functions for dispatchable functions

        // ACTION #6: function to randomly generate DNA

        // TODO Part III: mint

        // TODO Part IV: transfer_kitty_to
    }
}

serde를 팔렛의 Cargo.toml파일에 추가하기 맞는 버전 찾아서!!

kitty struct 구조

하나의 Kitty가 가지고 있어야 하는 정보

• dna : 고양이의 유니크한 속성인 dna를 식별하는데 사용되는 해시값. 새 고양이를 기르거나 다른 고양이 세대를 추적하는 데에도 사용됨 => [u8;16]
• price : 주인이 설정한, 고양이를 사는 데 필요한 금액 => BalanceOf FRAME의 Currency trait에 있는 커스텀 타입
• gender : Male or Female인 enum => Gender 타입 ! 곧 만들것임
• owner : 한 명의 주인을 가리키는 계정 id

구조체 선언하기 전에 BalanceOf와 AccountOf를 추가해줘야 함

Action1 부분을 다음으로 교체

type AccountOf<T> = <T as frame_system::Config>::AccountId;
type BalanceOf<T> =
    <<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;

// Struct for holding Kitty information.
#[derive(Clone, Encode, Decode, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
#[scale_info(skip_type_params(T))]
#[codec(mel_bound())]
pub struct Kitty<T: Config> {
    pub dna: [u8; 16],
    pub price: Option<BalanceOf<T>>,
    pub gender: Gender,
    pub owner: AccountOf<T>,
}

이 파일 맨 위에 use scale_info::TypeInfo; 이 줄 추가해서 우리의 구조체가 이 trait에 접근할 수 있도록 해주기

Gender 커스텀 타입 작성

1. Male, Female 값을 갖는 enum 선언 Action item 2 부분 다음 코드로 교체

   #[derive(Clone, Encode, Decode, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
   #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
   pub enum Gender {
    Male,
    Female,
   }

   enum 선언하기 전에 dereive 매크로 써줘야 함 우리 런타임의 다른 타입들과 소통하려면 이렇게 감싸줘야 함?

2. kitty struct에 helper function 구현하기 Gender type을 리턴하고 랜덤으로 Gender enum 값을 고르기 위해 랜덤 함수를 사용하는 gen_gender라는 퍼블릭 함수를 만들자

Action4를 다음 코드로 교체

fn gen_gender() -> Gender {
    let random = T::KittyRandomness::random(&b"gender"[..]).0;
    match random.as_ref()[0] % 2 {
        0 => Gender::Male,
        _ => Gender::Female,
    }
}

on-chain 무작위성 구현 위에서 아직 정의하지 않은 KittyRandomness라는 걸 사용했음 이제 알아볼까 frame_support에 있는 Randomness trait을 사용할 것

1. 팔렛의 Configuration trait에서, Randomness trait에 바운드된 새로운 타입 정의 Randomness trait은 output과 blocknumber 제네릭을 교체하기 위해 인자로 구체화해주는 게 필요함 우리의 경우, 이 trait을 사용해서 함수듸 결과값이 Blake2 128-bit hash가 되길 원함 ACtion 5를 다음으고 교체

   type KittyRandomness: Randomness<Self::Hash, Self::BlockNumber>;

2. 런타임에서 실제 타입을 구체화하기 팔렛 설정할 때 새 타입 추가한 거에, 구체적인 타입을 설정하기 위해 우리 런타임을 설정해줘야 함 노드 템플릿이 이미 RandomnessCollectiveFilp 팔렛을 가지고 있기 때문에 runtime/src/lib.rs 팡리 안에 KittyRandomness 타입을 선언해주기만 하면 됨

   impl pallet_kitties::Config for Runtime {
    type Event = Event;
    type Currency = Balances;
    type KittyRandomness = RandomnessCollectiveFlip; // <-- ACTION: add this line.
   }

3. 랜덤 DNA 생성하기 같은 블록에서 한 번 이상 이 함수를 호출할 때 다른 해시값을 얻기 위해 extrinsic__index를 사용할 것이고 blake_128도 사용할 것 ACtion6번째 줄을 다음으로 교체

fn gen_dna() -> [u8; 16] {
    let payload = (
        T::KittyRandomness::random(&b"dna"[..]).0,
        <frame_system::Pallet<T>>::extrinsic_index().unwrap_or_default(),
        <frame_system::Pallet<T>>::block_number(),
    );
    payload.using_encoded(blake2_128)
}

남은 스토리지 아이템들 작성 모든 고양이들을 쉽게 추적하기 위해서 유일한 아이디를 우리의 스토리지 아이템의 글로벌 키로 사용하는 로직을 표준화할 것임

새 고양이의 아이디는 항상 유일해야 함 해시값을 아이디로 갖고 그에 대한 고양이 오브젝트를 맵핑하는 Kitties 스토리지 아이템을 사용할 것임

Action 7을 교체

런타임은 Kitties라는 스토리지 맵으로 유일한 자산인 currency나 kitties

#[pallet::storage]
#[pallet::getter(fn kitties)]
pub(super) type Kitties<T: Config> = StorageMap<
    _,
    Twox64Concat,
    T::Hash,
    Kitty<T>,
>;

그 자산들의 소유권인 계정 아이디를 KittiesOwned라는 스토리지 맵으로 다룸

#[pallet::storage]
#[pallet::getter(fn kitties_owned)]
/// Keeps track of what accounts own what Kitty.
pub(super) type KittiesOwned<T: Config> = StorageMap<
    _,
    Twox64Concat,
    T::AccountId,
    BoundedVec<T::Hash, T::MaxKittyOwned>,
    ValueQuery,
>;

FRAME이 제공하는 StorageMap으로 Kitty 구조체의 스토리지 인스턴스 생성할 것

ACtion 9를 다음 줄로 교체

#[pallet::constant]
type MaxKittyOwned: Get<u32>;

MaxKittyowned라는 타입을 config trait에 추가

parameter_types! {              // <- add this macro
    // One can own at most 9,999 Kitties
    pub const MaxKittyOwned: u32 = 9999;
}

/// Configure the pallet-kitties in pallets/kitties.
impl pallet_kitties::Config for Runtime {
    type Event = Event;
    type Currency = Balances;
    type KittyRandomness = RandomnessCollectiveFlip;
    type MaxKittyOwned = MaxKittyOwned; // <- add this line
}

이 코드를 추가해라~~

컴파일 되는지 확인! cargo build --release

4. 디스패쳐블, 이벤트, 에러

• create_kitty : 한 계정이 고양이 한 마리를 민팅하게 허락하는 dispatchable 또는 publicly callable함수
• mint : 우리 팔렛의 스토리지 아이템을 업데이트하고 에러를 체크하는 create_kitty에 의해 호출되는 도우미 함수
• Events: FRAME의 #[pallet::event] attribute 사용

Public and Private 함수들 최적화를 위해 복잡한 로직을 private 도우미 함수로 쪼갤 것 private함수는 다양한 dispatchavle함수들에 의해 호출 가능

• create_kitty는 dispatchable 함수 또는 extrinsic임: origin이 sign받았는지 확인, 사인한 계정으로 랜덤 해시 생성, 그걸로 새로운 고양이 오브젝트 만들고 private mint()함수 호출

• mint는 private helper function: 그 고양이가 이미 존재하지 않는지 확인, 새 고양이 아이디로 스토리지 업데이트, 스토리지에 있는 새 총 고양이 개수와 새 주인의 계정 업데이트, 고양이가 성공적으로 만들어졌다ㅡㄴ 신호에 대한 이벤트 쌓기

create_kitty dispatchable 작성하기

FRAME에서 dispatchable은 항상 같은 구조임

모든 팔렛 dispatchables는 #[pallet::call] 매크로 아래에 있고, impl<T: Config>Pallet<T> {}로 선언되어야 함

• weights : 팔렛::call 의 요구사항에 따라, 모든 디스패쳐블 함수들은 연관 무게를 가져야 함 무게는 실행 시간에 블록을 맞추려고 계산의 양에 대해 세이프가드를 제공하기 때문에 서브스트레이트에서 개발하는 데 중요한 부분임

서브스트레이트의 weighting system은 개발자들이 연산 복잡도를 매 extrinsic에 대해 생각하도록 강제한다. 그래서 노드가 최악의 실행시간을 가정하게 하고 구체적인 블록 시간보다 더 오래 걸리는 extrinsic들과 네트워킹하는 것을 피하게 한다. 무게는 어떠한 사인된 extrinsic에 대해서도 수수료 시스템과도 내부적으로 연결되어 있음

pallets/kitties/src/lib.rs에서 action1을 다음으로 교체

  #[pallet::weight(100)]
pub fn create_kitty(origin: OriginFor<T>) -> DispatchResult {
    let sender = ensure_signed(origin)?; // <- add this line
    let kitty_id = Self::mint(&sender, None, None)?; // <- add this line
    // Logging to the console
    log::info!("A kitty is born with ID: {:?}.", kitty_id); // <- add this line

    // ACTION #4: Deposit `Created` event

    Ok(())
}                                                             

로깅하기 위해서 맞는 버전의 log::info Cargo.toml파일에 추가하기

mint() 함수 작성하기

• owner: &T::AccountId, 고양이 주인
• dna: Option<[u8;16]>, 만약 None이면 랜덤 DNA 생성됨
• gender: Option

  Result<T::Hash, Error<\T>>를 리턴

Action 2부분을 다음으로 교체

  // Helper to mint a Kitty.
pub fn mint(
    owner: &T::AccountId,
    dna: Option<[u8; 16]>,
    gender: Option<Gender>,
) -> Result<T::Hash, Error<T>> {
    let kitty = Kitty::<T> {
        dna: dna.unwrap_or_else(Self::gen_dna),
        price: None,
        gender: gender.unwrap_or_else(Self::gen_gender),
        owner: owner.clone(),
    };

    let kitty_id = T::Hashing::hash_of(&kitty);

    // Performs this operation first as it may fail
    let new_cnt = Self::count_for_kitties().checked_add(1)
        .ok_or(<Error<T>>::CountForKittiesOverflow)?;

    // Check if the kitty does not already exist in our storage map
    ensure!(Self::kitties(&kitty_id) == None, <Error<T>>::KittyExists);

    // Performs this operation first because as it may fail
    <KittiesOwned<T>>::try_mutate(&owner, |kitty_vec| {
        kitty_vec.try_push(kitty_id)
    }).map_err(|_| <Error<T>>::ExceedMaxKittyOwned)?;

    <Kitties<T>>::insert(kitty_id, kitty);
    <CountForKitties<T>>::put(new_cnt);
    Ok(kitty_id)
}

먼저 새 고양이 오브젝트를 생성 유일한 kitty_id를 고양이의 현재 특성에 기초한 해시 함수를 사용해 생성 CountForKitties를 스토리지 게터함수인 Self::count_for_kitties()를 사용해 증가시키고 check_add()함수로 오버플로우 확인 kitty_id가 이미 존재하지는 않는지 검사

검사 다 통과하면 스토리지 아이템을 업데이트: try_mutate로 고양이 주인 벡터 업데이트 섭스트레이트 스토리지 맵 API가 제공하는 insert 메소드로 실제 고양이 오브젝트를 저장하고 kitty_id와 연관시키기 StorageValue API에 의해 제공된 put으로 최신 고양이 개수 저장

pallet Events 구현하기 우리 팔렛은 함수 마지막에 이벤트도 발생시킬 수 있음 FRAME의 #[pallet::event]를 통해서 쉽게 팔렛의 이벤트를 관리하고 선언할 수 있음, FRAME 매크로로 이벤트를 enum 선언처럼 할 수 있음

  #[pallet::event]
#[pallet::generate_deposit(pub(super) fn deposit_event)]
pub enum Event<T: Config>{
    /// A function succeeded. [time, day]
    Success(T::Time, T::Day),
}

attribute macro인 #[pallet::generate_deposit(pub(super) fn deposit_event)]을 사용할 수 있음

이를 통해 특정 이벤트를 적립할 수 있음, ㅇSelf::deposit_event(Event::Success(var_time, var_day)); 이런 패턴을 통해서!

우리 팔렛의 설정 trait Config 안에다 새로운 연관 타입인 Event를 추가해줘야 함 그리고 runtime/src/lib.rs에도 추가해줘야 함 ``rust
/// Configure the pallet by specifying the parameters and types it depends on. #[pallet::config] pub trait Config: frame_system::Config { /// Because this pallet emits events, it depends on the runtime's definition of an event. type Event: From<Event> + IsType<::Event>; //--snip--// }

Action3을 다음으로 교체해서 이벤트 선언해라
```rust
  // A new Kitty was successfully created. \[sender, kitty_id\]
Created(T::AccountId, T::Hash),
/// Kitty price was successfully set. \[sender, kitty_id, new_price\]
PriceSet(T::AccountId, T::Hash, Option<BalanceOf<T>>),
/// A Kitty was successfully transferred. \[from, to, kitty_id\]
Transferred(T::AccountId, T::AccountId, T::Hash),
/// A Kitty was successfully bought. \[buyer, seller, kitty_id, bid_price\]
Bought(T::AccountId, T::AccountId, T::Hash, BalanceOf<T>),

Action 4를 다음으로 교체해서 완성해라 Self::deposit_event(Event::Created(sender, kitty_id));

에러 처리 FRAME을 통해 [#pallet::error]로 우리 팔렛에 에러를 구체화하고 팔렛 함수 안에서 사용할 수 있게 해줌 #[pallet::error]아래에 FRAME 매크로를 사용해서 가능한 모든 에러를 Action5줄로 교체

/// Handles arithmetic overflow when incrementing the Kitty counter.
CountForKittiesOverflow,
/// An account cannot own more Kitties than `MaxKittyCount`.
ExceedMaxKittyOwned,
/// Buyer cannot be the owner.
BuyerIsKittyOwner,
/// Cannot transfer a kitty to its owner.
TransferToSelf,
/// This kitty already exists
KittyExists,
/// This kitty doesn't exist
KittyNotExist,
/// Handles checking that the Kitty is owned by the account transferring, buying or setting a price for it.
NotKittyOwner,
/// Ensures the Kitty is for sale.
KittyNotForSale,
/// Ensures that the buying price is greater than the asking price.
KittyBidPriceTooLow,
/// Ensures that an account has enough funds to purchase a Kitty.
NotEnoughBalance,

다 잘 빌드되는지 확인 cargo build --release

Polkadat-JS Apps UI로 테스트하기 루트 디렉토리에서 다음 실행 ./target/release/node-kitties --tmp --dev

Developer에서 extrinsc으로 가서 사인된 extrincic을 substrateKitties를 사용해서 사인하고 제출하는데, createKitty 디스패쳐블 호출해서 해라. 앨리스, 밥, 찰리의 계정으로 해봐라

이벤트로 가서 Created찾고 블록 디테일 이벤트 실행된 거 확인가능해야 함

chain state가서 substrateKitties팔렛 가서 Kitties(hash)Kitty 쿼리 실행해서 디테일 확인 include option체크 안 한 상태에서만 다음 정보 볼 수 있음

5. Kittiy들과 상호작용하기

고양이 가격 설정

• 고양이 주인 확인 : 스토리지에 있는 오브젝트들을 수정하는 함수들을 만들면서 오직 적절한 사용자들만 성공적으로 그 디스패쳐블 ㅅ함수들의 로직을 실행할 수 있는지를 확인해야 함

  Action #1a에 붙여넣기 ensure!(Self::is_kitty_owner(&kitty_id, &sender)?, <Error>::NotKittyOwner);

  Action #1b에 붙여넣기 pub fn is_kitty_owner(kitty_id: &T::Hash, acct: &T::AccountId) -> Result<bool, Error> { match Self::kitties(kitty_id) {

  Some(kitty) => Ok(kitty.owner == *acct),
  None => Err(<Error<T>>::KittyNotExist)

  } }

• 우리 가격 업데이트: 스토리지에서 고양이 오브젝트 가져와서 새 가격으로 업데이트하고 다시 스토리지에 저장 ACtion2다음으로 교체

  kitty.price = new_price.clone();
  <Kitties<T>>::insert(&kitty_id, kitty);
  

• 이벤트 적립하기: 다 성공적으로 이뤄지면 이벤트 적립 가능 ACtion 3 다음으로 교체

  // Deposit a "PriceSet" event.
  Self::deposit_event(Event::PriceSet(sender, kitty_id, new_price));

고양이 교환 transfer(): 디스패쳐블 함수, publickly 호출가능하 다스패처블 transfer_kitty_to() : private helper function. transfer사 호출, 고양이 교환할 때 모든 스토리지 업데이트 담당

action 4

  #[pallet::weight(100)]
pub fn transfer(
    origin: OriginFor<T>,
    to: T::AccountId,
    kitty_id: T::Hash
) -> DispatchResult {
    let from = ensure_signed(origin)?;

    // Ensure the kitty exists and is called by the kitty owner
    ensure!(Self::is_kitty_owner(&kitty_id, &from)?, <Error<T>>::NotKittyOwner);

    // Verify the kitty is not transferring back to its owner.
    ensure!(from != to, <Error<T>>::TransferToSelf);

    // Verify the recipient has the capacity to receive one more kitty
    let to_owned = <KittiesOwned<T>>::get(&to);
    ensure!((to_owned.len() as u32) < T::MaxKittyOwned::get(), <Error<T>>::ExceedMaxKittyOwned);

    Self::transfer_kitty_to(&kitty_id, &to)?;

    Self::deposit_event(Event::Transferred(from, to, kitty_id));

    Ok(())
}

• 트랜잭션 사인됐나 확인하고

• 고양이 주인이 보냈나 확인하고 주인에게 보내는 거 아닌가 확인하고 받는 사람이 하나 이상의 고양이 가질 수 있는지 확인하고 transfer_kitty_to함수 실행

  Action5

  #[transactional]
  pub fn transfer_kitty_to(
  kitty_id: &T::Hash,
  to: &T::AccountId,
  ) -> Result<(), Error<T>> {
  let mut kitty = Self::kitties(&kitty_id).ok_or(<Error<T>>::KittyNotExist)?;
  
  let prev_owner = kitty.owner.clone();
  
  // Remove `kitty_id` from the KittiesOwned vector of `prev_owner`
  <KittiesOwned<T>>::try_mutate(&prev_owner, |owned| {
      if let Some(ind) = owned.iter().position(|&id| id == *kitty_id) {
          owned.swap_remove(ind);
          return Ok(());
      }
      Err(())
  }).map_err(|_| <Error<T>>::KittyNotExist)?;
  
  // Update the kitty owner
  kitty.owner = to.clone();
  // Reset the ask price so the kitty is not for sale until `set_price()` is called
  // by the current owner.
  kitty.price = None;
  
  <Kitties<T>>::insert(kitty_id, kitty);
  
  <KittiesOwned<T>>::try_mutate(to, |vec| {
      vec.try_push(*kitty_id)
  }).map_err(|_| <Error<T>>::ExceedMaxKittyOwned)?;
  
  Ok(())
  }

  #[transactional]은 오직 ok를 리턴할 때만 스토리지 바꿀 수 있도록 해줌

고양이 구매

그 고양이가 판매중인지 확인 현재가격이 사용자의 예산에 있는지와 충분한 free balance를 가지고 있는지 확인 ACtion 6 교체

  // Check the kitty is for sale and the kitty ask price <= bid_price
if let Some(ask_price) = kitty.price {
    ensure!(ask_price <= bid_price, <Error<T>>::KittyBidPriceTooLow);
} else {
    Err(<Error<T>>::KittyNotForSale)?;
}

// Check the buyer has enough free balance
ensure!(T::Currency::free_balance(&buyer) >= bid_price, <Error<T>>::NotEnoughBalance);

고ㅑㅇ이 받을 공간 있나 확인

Action7다음으로 교체

  // Verify the buyer has the capacity to receive one more kitty
let to_owned = <KittiesOwned<T>>::get(&buyer);
ensure!((to_owned.len() as u32) < T::MaxKittyOwned::get(), <Error<T>>::ExceedMaxKittyOwned);

let seller = kitty.owner.clone();

Action 8 // Transfer the amount from buyer to seller T::Currency::transfer(&buyer, &seller, bid_price, ExistenceRequirement::KeepAlive)?;

// Transfer the kitty from seller to buyer Self::transfer_kitty_to(&kitty_id, &buyer)?;

// Deposit relevant Event Self::deposit_event(Event::Bought(buyer, seller, kitty_id, bid_price));

고양이 기르기 ACtion 9 let new_dna = Self::breed_dna(&parent1, &parent2)?;

ACtino 10 Self::mint(&sender, Some(new_dna), None)?;

제네시스 설정 초기 상태 설정해주기 FRAME's #[pallet::genesis_config] 사용 제네시스 블록에 어떤 고양이 오브젝트 선언하도록 허용?

ACtion 11 // Our pallet's genesis configuration. #[pallet::genesis_config] pub struct GenesisConfig<T: Config> { pub kitties: Vec<(T::AccountId, [u8; 16], Gender)>, }

// Required to implement default for GenesisConfig. #[cfg(feature = "std")] impl<T: Config> Default for GenesisConfig { fn default() -> GenesisConfig { GenesisConfig { kitties: vec![] } } }

#[pallet::genesis_build] impl<T: Config> GenesisBuild for GenesisConfig { fn build(&self) { // When building a kitty from genesis config, we require the dna and gender to be supplied. for (acct, dna, gender) in &self.kitties { let _ = <Pallet>::mint(acct, Some(dna.clone()), Some(gender.clone())); } } }

node/src/chain_spec.rs로 가서 맨 위에 use node_kitties_runtime::SubstrateKittiesConfig; 추가하고 testnet_genesis함수에 추가 substrate_kitties: SubstrateKittiesConfig { kitties: vec![], },

빌드, 실행, 상호작용하기 cargo build --release ./target/release/node-kitties --dev --tmp

Fund multiple users with tokens so they can all participate Have each user create multiple Kitties Try to transfer a Kitty from one user to another using the right and wrong owner Try to set the price of a Kitty using the right and wrong owner Buy a Kitty using an owner and another user Use too little funds to purchase a Kitty Overspend on the cost of the Kitty and ensure that the balance is reduced appropriately Breed a Kitty and check that the new DNA is a mix of the old and new

]]> https://velog.io/@myungha_cho/Rust-7 https://velog.io/@myungha_cho/Rust-7 Sun, 08 May 2022 11:33:29 GMT Packages, Crates, Modules

1. 패키지와 크레이트

크레이트는 바이너리/라이브러리 패키지는 여러 기능을 제공하는 하나 이상의 크레이트 패키지는 최대 하나의 라이브러리 크레이트를 가질 수 있다. 패키지는 여러 바이너리 크레이트를 가질 수 있지만, 최소 하나의 바이너리 크레이트는 가지고 있어야 함

바이너리 1개만 존재 : src/main.rs 라이브러리 1개/바이너리 1개 : src/main.rs, src/lib.rs 라이브러리 1개/바이너리 여러 개 : src.bin/..., 각 바이너리 크레이트들으 src/bin 디렉토리 안에 두여야 함

2. 모듈

모듈은 크레이트 안에서 코드를 그룹별로 정리하게 쉽게 해줌 각 항목들이 pulbic이어도 되는지, private이어야 하는지 정리 가능

mod front_of_house { mod hosting { fn add_to_waitlist() {}

    fn seat_at_table() {}
}

mod serving {
    fn take_order() {}

    fn serve_order() {}

    fn take_payment() {}
}

}

모듈 트리

crate └── front_of_house ├── hosting │ ├── add_to_waitlist │ └── seat_at_table └── serving ├── take_order ├── serve_order └── take_payment

3. path

모듈 트리에서 내가 원하는 항목 찾기 위해 path 경로를 사용한다.

• 절대 경로 : crate에서 시작
• 상대 경로 : 이름으로 시작하는 건 상대경로 의미

기본적으로 모든 아이템이 private 부모 모듈에 ㅇㅆ는 항목들은 자식 모듈에 이쓴 private항목을 사용하지 못함

자식 모듈에 이쓴 항목들은 부모 모듈에 이쓴 항속 사용 ㅎ가능

자식 모듈에 이쓴 거를 공개하고 싶을 때 앞에 pub 키워드 붙임

mod front_of_house { pub mod hosting { pub fn add_to_waitlist() {} } }

pub fn eat_at_restaurant() { // Absolute path crate::front_of_house::hosting::add_to_waitlist();

// Relative path
front_of_house::hosting::add_to_waitlist();

}

super 키워드를 사용해서 상대 경로 쉽게 적을 수 있음

struct로 만들면 기본적으로 private이지만 enum으로 만들면 기본적으로 public이다

4. use

use 키워드로 경로 짧게 표현 가능 함수를 불러올 때는 부모에서부터 가졍ㅁ struct, enum 다른ㄴ 아이템ㅇ들은절대경로로 가져옴 이름이 같은 항목이 있으면 부모 모듈로 가져옴

아니면 이름이 같으면 as로 다른 이름 붙여도 됨

pub use

mod front_of_house { pub mod hosting { pub fn add_to_waitlist() {} } }

pub use crate::front_of_house::hosting;

pub fn eat_at_restaurant() { hosting::add_to_waitlist(); hosting::add_to_waitlist(); hosting::add_to_waitlist(); }

listing them in your package’s Cargo.toml file and using use to bring items from their crates into scope

짧은 경로로 내가 선언한 함수 호출 가능

use std::{cmp::Ordering, io}; use std::io::{self, Write}; use std::collections::*;

5. 다른 파일로 모듈 분리하기

]]> https://velog.io/@myungha_cho/Rust-6 https://velog.io/@myungha_cho/Rust-6 Sun, 08 May 2022 07:42:09 GMT

Enums and Pattern Matching

enum

enum IpAddrKind {
 V4,
 V6,
}

fn main() { let four = IpAddrKind::V4; let six = IpAddrKind::V6;

route(IpAddrKind::V4);
route(IpAddrKind::V6);

}

fn route(ip_kind: IpAddrKind) {}

```rust

struct IpAddr {
        kind: IpAddrKind,
        address: String,
    }

let home = IpAddr {
        kind: IpAddrKind::V4,
        address: String::from("127.0.0.1"),
};

let loopback = IpAddr {
        kind: IpAddrKind::V6,
        address: String::from("::1"),
};


fn main() {
    enum IpAddr {
        V4(String),
        V6(String),
    }

    let home = IpAddr::V4(String::from("127.0.0.1"));

    let loopback = IpAddr::V6(String::from("::1"));
}

the name of each enum variant that we define also becomes a function that constructs an instance of the enum. That is, IpAddr::V4() is a function call that takes a String argument and returns an instance of the IpAddr type. We automatically get this constructor function defined as a result of defining the enum.

enum안에는 어떤 자료형이든지 넣을 수 있다

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {}

struct QuitMessage; // unit struct
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // tuple struct
struct ChangeColorMessage(i32, i32, i32); // tuple struct

fn main() {}

이렇게 struct로 선언할 수도 있지만, 그러면 enum처럼 이것들을 다 하나의 타입으로 받는 함수를 만들기가 쉽지가 않음

impl 키워드로 enum에도 메소드 정의가능(sturct와 공통점)

fn main() {
    enum Message {
        Quit,
        Move { x: i32, y: i32 },
        Write(String),
        ChangeColor(i32, i32, i32),
    }

    impl Message {
        fn call(&self) {
            // method body would be defined here
        }
    }

    let m = Message::Write(String::from("hello"));
    m.call();
}

Option Enum 표준라이브러리에 정의된 enum

fn main() {
    enum Option<T> {
        None,
        Some(T),
    }

    let some_number = Some(5);
    let some_string = Some("a string");

    let absent_number: Option<i32> = None;

}

fn main() {
    let x: i8 = 5;
    let y: Option<i8> = Some(5);

    let sum = x + y;
}

In short, because Optio<\T> and T (where T can be any type) are different types, the compiler won’t let us use an Option value as if it were definitely a valid value. For example, this code won’t compile because it’s trying to add an i8 to an Option i8과 Option은 서로 다른 타입으로 인식해서 컴파일 안 됨

match

Patterns can be made up of literal values, variable names, wildcards, and many other things 패턴에 따라 다른 코드블록 실행시켜줌

  enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {:?}!", state);
            25
        }
    }

}

fn main() {}

러스트에서 match는 모든 가능한 경우를 다 다뤄줘야 함

fn main() { let dice_roll = 9; match dice_roll { 3 => add_fancy_hat(), 7 => remove_fancy_hat(), other => move_player(other), }

  match dice_roll {
    3 => add_fancy_hat(),
    7 => remove_fancy_hat(),
    _ => reroll(),
       _ => (),
}

fn add_fancy_hat() {}
fn remove_fancy_hat() {}
fn move_player(num_spaces: u8) {}

}

catch-all 은 맨 마지막에 써야 함 위처럼 함수로 인자 받기도 싫으면 _, 사용하면 됨

if let

하나의 패턴에만 코드 실행하고 나머지는 무시하고 싶을 때 사용

fn main() { let coin = Coin::Penny; let mut count = 0; if let Coin::Quarter(state) = coin { println!("State quarter from {:?}!", state); } else { count += 1; } }

]]>