이 글이 하나의 좋은 한국어 개발 튜토리얼이 되길 바라며! 내가 사용한 Rust 스마트 컨트랙트 작성과 NEAR 테스트넷에 배포하는 방식을 적어보겠다.

필요 사항

1. NEAR 테스트넷 계정
2. near-cli 설치
3. Rust tool chain 설치

컨트랙트 배포

사용 기술 설명

1. Cargo 이용

• rust는 node.js의 npm처럼 cargo라는 관리 툴을 이용한다.

2. Rust는 어셈블리어인 wasm파일을 만든 후, 이를 블록체인에 배포하는 형식으로 진행한다.

• rust로 작성된 컨트랙트를 wasm파일로 컴파일 한 후, 원하는 블록체인 네트워크에 배포하는 방식을 이용한다.

  절차

  STEP 1 레포지토리 만들기

  $ cargo new <나의 레포지토리 이름>
  $ cd <레포지토리>

• cargo의 new 명령어를 이용해 cargo 환경이 세팅된 레포지토리를 생성한다.

  .
  ├── Cargo.toml
  └── src
   └── main.rs

• 생성된 레포지토리의 구조는 다음과 같다.
• src폴더 내부에 .rs 확장자로 되어있는 컨트랙트를 작성하고 배포하는 구조이다.

  STEP 2 스마트 컨트랙트 작성하기

  스마트 컨트랙트를 계약 내용을 직접 명시하는 것이나 현실의 계약서와 같은 개념이라고 보면 개발할 때 많은 혼란이 있을 것이다. 스마트 컨트랙트는 하나의 인터페이스, 블록체인에 올라가는 데이터 틀을 만든다고 생각하면 더 편하게 이해할 수 있다.

나는 NFT를 발행하고 거래하는 플랫폼을 개발 중이어서 NEAR의 nft표준인 NEP-171 표준을 따르는 스마트 컨트랙트를 작성했다. NEP-171 표준을 사용하여 컨트랙트를 작성하면 해당 표준을 공유하는 NFT간 공유가 가능하다.

• 내가 만들고 있는 nft 플랫폼의 경우 nft를 발행하는 mint, nft의 개수를 세는 기능인 enumerable, nft 내부 정보를 관리하는 internal, nft에 이미지 등의 정보를 넣을 수 있는 metadata, NEP-171 표준을 명시하는 nft_core의 기능이 필요했다.
• 많은 기능을 한 컨트랙트에 넣을 수 있지만, 분리하면 frontend와의 상호작용에 매우 편리하므로, 분리해서 넣었다.

핵심기능 1 mint.rs

• nft를 발행하는 기능이 들어가는 컨트랙트이다.
• nft_mint 함수를 구현한다.
• 발행 시 유저가 정한 토큰 아이디와, 메타데이터, 로열티, 받는 사람과 토큰 타입을 저장한다.

전체 코드

use crate::*;

#[near_bindgen]
impl Contract {
    #[payable]
    pub fn nft_mint(
        &mut self,
        token_id: Option<TokenId>,
        metadata: TokenMetadata,
        perpetual_royalties: Option<HashMap<AccountId, u32>>,
        receiver_id: Option<ValidAccountId>,
        token_type: Option<TokenType>,
    ) {

        let mut final_token_id = format!("{}", self.token_metadata_by_id.len() + 1);
        if let Some(token_id) = token_id {
            final_token_id = token_id
        }

        let initial_storage_usage = env::storage_usage();
        let mut owner_id = env::predecessor_account_id();
        if let Some(receiver_id) = receiver_id {
            owner_id = receiver_id.into();
        }

        // CUSTOM - create royalty map
        let mut royalty = HashMap::new();
        let mut total_perpetual = 0;
        // user added perpetual_royalties (percentage paid with every transfer)
        if let Some(perpetual_royalties) = perpetual_royalties {
            assert!(perpetual_royalties.len() < 7, "Cannot add more than 6 perpetual royalty amounts");
            for (account, amount) in perpetual_royalties {
                royalty.insert(account, amount);
                total_perpetual += amount;
            }
        }
        // royalty limit for minter capped at 20%
        assert!(total_perpetual <= MINTER_ROYALTY_CAP, "Perpetual royalties cannot be more than 20%");

        // CUSTOM - enforce minting caps by token_type 
        if token_type.is_some() {
            let token_type = token_type.clone().unwrap();
            let cap = u64::from(*self.supply_cap_by_type.get(&token_type).expect("Token type must have supply cap."));
            let supply = u64::from(self.nft_supply_for_type(&token_type));
            assert!(supply < cap, "Cannot mint anymore of token type.");
            let mut tokens_per_type = self
                .tokens_per_type
                .get(&token_type)
                .unwrap_or_else(|| {
                    UnorderedSet::new(
                        StorageKey::TokensPerTypeInner {
                            token_type_hash: hash_account_id(&token_type),
                        }
                        .try_to_vec()
                        .unwrap(),
                    )
                });
            tokens_per_type.insert(&final_token_id);
            self.tokens_per_type.insert(&token_type, &tokens_per_type);
        }
        // END CUSTOM

        let token = Token {
            owner_id,
            approved_account_ids: Default::default(),
            next_approval_id: 0,
            royalty,
            token_type,
        };
        assert!(
            self.tokens_by_id.insert(&final_token_id, &token).is_none(),
            "Token already exists"
        );
        self.token_metadata_by_id.insert(&final_token_id, &metadata);
        self.internal_add_token_to_owner(&token.owner_id, &final_token_id);

        let new_token_size_in_bytes = env::storage_usage() - initial_storage_usage;
        let required_storage_in_bytes =
            self.extra_storage_in_bytes_per_token + new_token_size_in_bytes;

        refund_deposit(required_storage_in_bytes);
    }
}

핵심기능 2 nft_core.rs

• NEP-171 표준을 구현한다.
• nft_transfer, nft_approve, nft_revoke등 nft를 거래하기 위해 필요한 함수를 구현한다.
• 코어의 경우 커스텀이 필요한 부분이 적어 NEP-171 github를 참고하여 작성하였다.

  전체 코드

  use crate::*;
  use near_sdk::json_types::{ValidAccountId};
  use near_sdk::{ext_contract, log, Gas, PromiseResult};
  

const GAS_FOR_NFT_APPROVE: Gas = 10_000_000_000_000; const GAS_FOR_RESOLVE_TRANSFER: Gas = 10_000_000_000_000; const GAS_FOR_NFT_TRANSFER_CALL: Gas = 25_000_000_000_000 + GAS_FOR_RESOLVE_TRANSFER; const NO_DEPOSIT: Balance = 0;

pub trait NonFungibleTokenCore { fn nft_transfer( &mut self, receiver_id: ValidAccountId, token_id: TokenId, approval_id: u64, memo: Option, );

  fn nft_payout(&self, token_id: String, balance: U128, max_len_payout: u32) -> Payout;

fn nft_transfer_payout(
    &mut self,
    receiver_id: ValidAccountId,
    token_id: TokenId,
    approval_id: u64,
    memo: String,
    balance: U128,
    max_len_payout: u32,
) -> Payout;

/// Returns `true` if the token was transferred from the sender's account.
fn nft_transfer_call(
    &mut self,
    receiver_id: ValidAccountId,
    token_id: TokenId,
    approval_id: u64,
    memo: Option<String>,
    msg: String,
) -> PromiseOrValue<bool>;

fn nft_approve(&mut self, token_id: TokenId, account_id: ValidAccountId, msg: Option<String>);

fn nft_is_approved(
    &self,
    token_id: TokenId,
    approved_account_id: AccountId,
    approval_id: Option<u64>,
) -> bool;

fn nft_revoke(&mut self, token_id: TokenId, account_id: ValidAccountId);

fn nft_revoke_all(&mut self, token_id: TokenId);

fn nft_total_supply(&self) -> U128;

fn nft_token(&self, token_id: TokenId) -> Option<JsonToken>;

}

#[ext_contract(ext_non_fungible_token_receiver)] trait NonFungibleTokenReceiver { /// Returns true if the token should be returned back to the sender. fn nft_on_transfer( &mut self, sender_id: AccountId, previous_owner_id: AccountId, token_id: TokenId, msg: String, ) -> Promise; }

#[ext_contract(ext_non_fungible_approval_receiver)] trait NonFungibleTokenApprovalsReceiver { fn nft_on_approve( &mut self, token_id: TokenId, owner_id: AccountId, approval_id: u64, msg: String, ); }

// TODO: create nft_on_revoke

#[ext_contract(ext_self)] trait NonFungibleTokenResolver { fn nft_resolve_transfer( &mut self, owner_id: AccountId, receiver_id: AccountId, token_id: TokenId, approved_account_ids: HashMap<AccountId, u64>, ) -> bool; }

trait NonFungibleTokenResolver { fn nft_resolve_transfer( &mut self, owner_id: AccountId, receiver_id: AccountId, token_id: TokenId, approved_account_ids: HashMap<AccountId, u64>, ) -> bool; }

#[near_bindgen] impl NonFungibleTokenCore for Contract {

#[payable]
fn nft_transfer(
    &mut self,
    receiver_id: ValidAccountId,
    token_id: TokenId,
    approval_id: u64,
    memo: Option<String>,
) {
    assert_one_yocto();
    let sender_id = env::predecessor_account_id();
    let previous_token = self.internal_transfer(
        &sender_id,
        receiver_id.as_ref(),
        &token_id,
        Some(approval_id),
        memo,
    );
    refund_approved_account_ids(
        previous_token.owner_id.clone(),
        &previous_token.approved_account_ids,
    );
}

fn nft_payout(&self, token_id: String, balance: U128, max_len_payout: u32) -> Payout {
    let token = self.tokens_by_id.get(&token_id).expect("No token");

    // compute payouts based on balance option
    // adds in contract_royalty and computes previous owner royalty from remainder
    let owner_id = token.owner_id;
    let mut total_perpetual = 0;
    let balance_u128 = u128::from(balance);
    let mut payout: Payout = HashMap::new();
    let royalty = token.royalty;

    assert!(royalty.len() as u32 <= max_len_payout, "Market cannot payout to that many receivers");

    for (k, v) in royalty.iter() {
        let key = k.clone();
        if key != owner_id {
            payout.insert(key, royalty_to_payout(*v, balance_u128));
            total_perpetual += *v;
        }
    }

    // payout to contract owner - may be previous token owner, they get remainder of balance
    if self.contract_royalty > 0 && self.owner_id != owner_id {
        payout.insert(self.owner_id.clone(), royalty_to_payout(self.contract_royalty, balance_u128));
        total_perpetual += self.contract_royalty;
    }
    assert!(total_perpetual <= MINTER_ROYALTY_CAP + CONTRACT_ROYALTY_CAP, "Royalties should not be more than caps");
    // payout to previous owner
    payout.insert(owner_id, royalty_to_payout(10000 - total_perpetual, balance_u128));

    payout
}

#[payable]
fn nft_transfer_payout(
    &mut self,
    receiver_id: ValidAccountId,
    token_id: TokenId,
    approval_id: u64,
    memo: String,
    balance: U128,
    max_len_payout: u32,
) -> Payout {
    assert_one_yocto();
    let sender_id = env::predecessor_account_id();
    let previous_token = self.internal_transfer(
        &sender_id,
        receiver_id.as_ref(),
        &token_id,
        Some(approval_id),
        Some(memo),
    );
    refund_approved_account_ids(
        previous_token.owner_id.clone(),
        &previous_token.approved_account_ids,
    );

    // compute payouts based on balance option
    // adds in contract_royalty and computes previous owner royalty from remainder
    let owner_id = previous_token.owner_id;
    let mut total_perpetual = 0;
    let balance_u128 = u128::from(balance);
    let mut payout: Payout = HashMap::new();
    let royalty = self.tokens_by_id.get(&token_id).expect("No token").royalty;

    assert!(royalty.len() as u32 <= max_len_payout, "Market cannot payout to that many receivers");

    for (k, v) in royalty.iter() {
        let key = k.clone();
        if key != owner_id {
            payout.insert(key, royalty_to_payout(*v, balance_u128));
            total_perpetual += *v;
        }
    }

    // payout to contract owner - may be previous token owner, they get remainder of balance
    if self.contract_royalty > 0 && self.owner_id != owner_id {
        payout.insert(self.owner_id.clone(), royalty_to_payout(self.contract_royalty, balance_u128));
        total_perpetual += self.contract_royalty;
    }
    assert!(total_perpetual <= MINTER_ROYALTY_CAP + CONTRACT_ROYALTY_CAP, "Royalties should not be more than caps");
    // payout to previous owner
    payout.insert(owner_id, royalty_to_payout(10000 - total_perpetual, balance_u128));

    payout
}

#[payable]
fn nft_transfer_call(
    &mut self,
    receiver_id: ValidAccountId,
    token_id: TokenId,
    approval_id: u64,
    memo: Option<String>,
    msg: String,
) -> PromiseOrValue<bool> {
    assert_one_yocto();
    let sender_id = env::predecessor_account_id();
    let previous_token = self.internal_transfer(
        &sender_id,
        receiver_id.as_ref(),
        &token_id,
        Some(approval_id),
        memo,
    );
    // Initiating receiver's call and the callback
    ext_non_fungible_token_receiver::nft_on_transfer(
        sender_id,
        previous_token.owner_id.clone(),
        token_id.clone(),
        msg,
        receiver_id.as_ref(),
        NO_DEPOSIT,
        env::prepaid_gas() - GAS_FOR_NFT_TRANSFER_CALL,
    )
    .then(ext_self::nft_resolve_transfer(
        previous_token.owner_id,
        receiver_id.into(),
        token_id,
        previous_token.approved_account_ids,
        &env::current_account_id(),
        NO_DEPOSIT,
        GAS_FOR_RESOLVE_TRANSFER,
    )).into()
}

#[payable]
fn nft_approve(&mut self, token_id: TokenId, account_id: ValidAccountId, msg: Option<String>) {
    assert_at_least_one_yocto();
    let account_id: AccountId = account_id.into();

    let mut token = self.tokens_by_id.get(&token_id).expect("No token");

    assert_eq!(
        &env::predecessor_account_id(),
        &token.owner_id,
        "Predecessor must be the token owner."
    );

    let approval_id: u64 = token.next_approval_id;
    let is_new_approval = token
        .approved_account_ids
        .insert(account_id.clone(), approval_id)
        .is_none();

    let storage_used = if is_new_approval {
        bytes_for_approved_account_id(&account_id)
    } else {
        0
    };

    token.next_approval_id += 1;
    self.tokens_by_id.insert(&token_id, &token);

    refund_deposit(storage_used);

    if let Some(msg) = msg {

        // CUSTOM - add token_type to msg
        let mut final_msg = msg;
        let token_type = token.token_type;
        if let Some(token_type) = token_type {
            final_msg.insert_str(final_msg.len() - 1, &format!(",\"token_type\":\"{}\"", token_type));
        }

        ext_non_fungible_approval_receiver::nft_on_approve(
            token_id,
            token.owner_id,
            approval_id,
            final_msg,
            &account_id,
            NO_DEPOSIT,
            env::prepaid_gas() - GAS_FOR_NFT_APPROVE,
        )
        .as_return(); // Returning this promise
    }
}

fn nft_is_approved(
    &self,
    token_id: TokenId,
    approved_account_id: AccountId,
    approval_id: Option<u64>,
) -> bool {
    let token = self.tokens_by_id.get(&token_id).expect("No token");
    let approval = token.approved_account_ids.get(&approved_account_id);
    if let Some(approval) = approval {
        if let Some(approval_id) = approval_id {
            approval_id == *approval
        } else {
            false
        }
    } else {
        false
    }
}

#[payable]
fn nft_revoke(&mut self, token_id: TokenId, account_id: ValidAccountId) {
    assert_one_yocto();
    let mut token = self.tokens_by_id.get(&token_id).expect("No token");
    let predecessor_account_id = env::predecessor_account_id();
    assert_eq!(&predecessor_account_id, &token.owner_id);
    if token
        .approved_account_ids
        .remove(account_id.as_ref())
        .is_some()
    {
        refund_approved_account_ids_iter(predecessor_account_id, [account_id.into()].iter());
        self.tokens_by_id.insert(&token_id, &token);
    }
}

#[payable]
fn nft_revoke_all(&mut self, token_id: TokenId) {
    assert_one_yocto();
    let mut token = self.tokens_by_id.get(&token_id).expect("No token");
    let predecessor_account_id = env::predecessor_account_id();
    assert_eq!(&predecessor_account_id, &token.owner_id);
    if !token.approved_account_ids.is_empty() {
        refund_approved_account_ids(predecessor_account_id, &token.approved_account_ids);
        token.approved_account_ids.clear();
        self.tokens_by_id.insert(&token_id, &token);
    }
}

fn nft_total_supply(&self) -> U128 {
    U128(self.token_metadata_by_id.len() as u128)
}

fn nft_token(&self, token_id: TokenId) -> Option<JsonToken> {
    if let Some(token) = self.tokens_by_id.get(&token_id) {
        let metadata = self.token_metadata_by_id.get(&token_id).unwrap();
        Some(JsonToken {
            token_id,
            owner_id: token.owner_id,
            metadata,
            royalty: token.royalty,
            approved_account_ids: token.approved_account_ids,
            token_type: token.token_type,
        })
    } else {
        None
    }
}

}

#[near_bindgen] impl NonFungibleTokenResolver for Contract { #[private] fn nft_resolve_transfer( &mut self, owner_id: AccountId, receiver_id: AccountId, token_id: TokenId, approved_account_ids: HashMap<AccountId, u64>, ) -> bool { // Whether receiver wants to return token back to the sender, based on nft_on_transfer // call result. if let PromiseResult::Successful(value) = env::promise_result(0) { if let Ok(return_token) = near_sdk::serde_json::from_slice::(&value) { if !return_token { // Token was successfully received. refund_approved_account_ids(owner_id, &approved_account_ids); return true; } } }

    let mut token = if let Some(token) = self.tokens_by_id.get(&token_id) {
        if token.owner_id != receiver_id {
            // The token is not owner by the receiver anymore. Can't return it.
            refund_approved_account_ids(owner_id, &approved_account_ids);
            return true;
        }
        token
    } else {
        // The token was burned and doesn't exist anymore.
        refund_approved_account_ids(owner_id, &approved_account_ids);
        return true;
    };

    log!("Return {} from @{} to @{}", token_id, receiver_id, owner_id);

    self.internal_remove_token_from_owner(&receiver_id, &token_id);
    self.internal_add_token_to_owner(&owner_id, &token_id);
    token.owner_id = owner_id;
    refund_approved_account_ids(receiver_id, &token.approved_account_ids);
    token.approved_account_ids = approved_account_ids;
    self.tokens_by_id.insert(&token_id, &token);

    false
}

}

#### 핵심기능 3 metadata.rs
- 발행하고자 하는 nft의 특징이 가장 잘 드러나는 부분이 metadata이다.
- 토큰의 필요한 정보들을 저장한다.
- 나의 플랫폼에 필요한 메타 데이터는 제목, 설명, 그림, 그림해시, nft 총 발행 개수, 발행처, 체인의 블록 생성 주기, 레퍼런스 URL이었다.

#### 전체 코드
```rust
use crate::*;

#[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize, Clone)]
#[serde(crate = "near_sdk::serde")]
pub struct NFTMetadata {
    pub spec: String,              // required, essentially a version like "nft-1.0.0"
    pub name: String,              // required, ex. "Mosaics"
    pub symbol: String,            // required, ex. "MOSIAC"
    pub icon: Option<String>,      // Data URL
    pub base_uri: Option<String>, // Centralized gateway known to have reliable access to decentralized storage assets referenced by `reference` or `media` URLs
    pub reference: Option<String>, // URL to a JSON file with more info
    pub reference_hash: Option<Base64VecU8>, // Base64-encoded sha256 hash of JSON from reference field. Required if `reference` is included.
}

#[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
#[serde(crate = "near_sdk::serde")]
pub struct TokenMetadata {
    pub title: Option<String>, // ex. "Arch Nemesis: Mail Carrier" or "Parcel #5055"
    pub description: Option<String>, // free-form description
    pub media: Option<String>, // URL to associated media, preferably to decentralized, content-addressed storage
    pub media_hash: Option<Base64VecU8>, // Base64-encoded sha256 hash of content referenced by the `media` field. Required if `media` is included.
    pub copies: Option<u64>, // number of copies of this set of metadata in existence when token was minted.
    pub issued_at: Option<u64>, // When token was issued or minted, Unix epoch in milliseconds
    pub expires_at: Option<u64>, // When token expires, Unix epoch in milliseconds
    pub starts_at: Option<u64>, // When token starts being valid, Unix epoch in milliseconds
    pub updated_at: Option<u64>, // When token was last updated, Unix epoch in milliseconds
    pub extra: Option<String>, // anything extra the NFT wants to store on-chain. Can be stringified JSON.
    pub reference: Option<String>, // URL to an off-chain JSON file with more info.
    pub reference_hash: Option<Base64VecU8>, // Base64-encoded sha256 hash of JSON from reference field. Required if `reference` is included.
}

pub trait NonFungibleTokenMetadata {
    fn nft_metadata(&self) -> NFTMetadata;
}

#[near_bindgen]
impl NonFungibleTokenMetadata for Contract {
    fn nft_metadata(&self) -> NFTMetadata {
        self.metadata.get().unwrap()
    }
}

STEP 3 wasm 파일로 컴파일하기

cargo build --target wasm32-unknown-unknown --release

• cargo의 build 명령어를 사용해 rust컨트랙트를 기계어로 컴파일한 wasm파일을 만든다.

  .
  ├── Cargo.lock  ⟵ dependency들을 저장해놓는 Lock파일, 자동 생성된다.
  ├── Cargo.toml
  ├── src
  │  └── 나의스마트컨트랙트.rs
  └── target      ⟵ target 레포지토리 내부에 wasm 파일이 자동으로 저장된다.
  

- build 이후 레포지토리에 Cargo.lock 파일과 target 폴더가 자동 생성된다.
- target 폴더 내부에 컴파일된 wasm 파일을 확인할 수 있다.
- target에 해당 파일이 생성된 것을 확인할 수 있다.

### STEP 4 컨트랙트 블록체인에 배포하기
#### near cli 로그인

near login

- near의 login 명령어를 이용해 near계정에 로그인한다.
- near의 wallet 웹이 자동으로 실행되며, 웹에서 로그인한 결과가 near cli에 반영된다.
- default 설정은 testnet이며, 메인넷이나 베타넷 배포를 희망할 경우 network 옵션을 추가하여 명령어를 실행하면 된다.
#### 컨트랙트 블록체인에 배포하기

near deploy --wasmFile target/wasm32-unknown-unknown/release/<내파일이름>.wasm --accountId <나의accountID (0000.testnet)>

```

• near의 deploy 명령어를 이용해 STEP 3에서 만들었던 wasm 파일을 배포한다.
• near는 자신의 account와 컨트랙트 아이디가 매칭되는 방식을 이용한다. --accountId 옵션에 정확한 자신의 account 아이디를 적자!

배포 확인하기

• NEAR explorer에서 자신의 어카운트 아이디를 검색하여 자신의 컨트랙트가 정상적으로 배포되었는지 확인해볼 수 있다.

문제 풀이

사용 개념

• 문제를 보면 앞에서부터 element를 뽑고, 다시 계산한 값을 앞에 넣어야 해서 앞 뒤에서 넣고 빼는게 자유로운 dequeue가 적절하다고 생각했다.
• 또한, 연산자마다 if문 걸기에는 너무 코드가 길어질 것 같아서 switch 문을 오랜만에 써봤다.

  핵심 코드

  //두 숫자 연산을 하니까 두 개를 뽑아서 저장하려고 선언 먼저
        String e1 = null;
        String e2 = null;
        //스택에 요소가 있을 때 계속 반복
        while (!dequeue.isEmpty()) {
            //맨 앞 요소를 뽑아서 검사
            String cur = dequeue.removeFirst();
            //switch문으로 검사, 우선 연산자일 경우 각각 계산하도록 처리한다
            switch (cur) {
                case "*":
                    //먼저 string으로 넣어놨으니까 Integer.parseInt로 숫자로 바꿈
                    int temp = Integer.parseInt(e1) * Integer.parseInt(e2);
                    //바꾼 다음 연산한 값을 덱의 맨 처음에 넣는다.
                    dequeue.addFirst(String.valueOf(temp));
                    e1 = e2 = null;
                    break;
                case "/":
                    temp = Integer.parseInt(e1) / Integer.parseInt(e2);
                    dequeue.addFirst(String.valueOf(temp));
                    e1 = e2 = null;
                    break;
                case "+":
                    temp = Integer.parseInt(e1) + Integer.parseInt(e2);
                    dequeue.addFirst(String.valueOf(temp));
                    e1 = e2 = null;
                    break;
                case "-":
                    temp = Integer.parseInt(e1) - Integer.parseInt(e2);
                    dequeue.addFirst(String.valueOf(temp));
                    e1 = e2 = null;
                    break;
                default:
                    if (e1 == null) {
                        e1 = cur;
                    }
                    else if (e2 == null) {
                        e2 = cur;
                    }
                    if (dequeue.size() == 0) {
                        System.out.println(cur);
                        break;
                    }
                    break;
            }
        }

  • 코드가 또 구구절절이라서.. 이거 그냥 dequeue 말고 stack으로 풀어봐야겠다는 생각이 들었다.
  • dequeue 나와있는 자료 구조를 이용했고, 처음에 넣고 빼기 위해서 removeFirst, addFirst 를 썼다.
• 맨 마지막에 숫자면서 하나밖에 안남아있는 경우 완결된 답이므로 default의 dequeue 사이즈 검사를 이용했다.

  최종 코드

  package EPPER;
  

import java.util.ArrayDeque; import java.util.Deque; import java.util.Scanner;

public class EPPER_15_6 { public static void main(String[] args) { Deque dequeue = new ArrayDeque<>(); Scanner s = new Scanner(System.in); int m = s.nextInt(); for (int i = 0; i < m; i++) { dequeue.add(s.next()); }

    //두 숫자 연산을 하니까 두 개를 뽑아서 저장하려고 선언 먼저
    String e1 = null;
    String e2 = null;
    //스택에 요소가 있을 때 계속 반복
    while (!dequeue.isEmpty()) {
        //맨 앞 요소를 뽑아서 검사
        String cur = dequeue.removeFirst();
        //switch문으로 검사, 우선 연산자일 경우 각각 계산하도록 처리한다
        switch (cur) {
            case "*":
                //먼저 string으로 넣어놨으니까 Integer.parseInt로 숫자로 바꿈
                int temp = Integer.parseInt(e1) * Integer.parseInt(e2);
                //바꾼 다음 연산한 값을 덱의 맨 처음에 넣는다.
                dequeue.addFirst(String.valueOf(temp));
                e1 = e2 = null;
                break;
            case "/":
                temp = Integer.parseInt(e1) / Integer.parseInt(e2);
                dequeue.addFirst(String.valueOf(temp));
                e1 = e2 = null;
                break;
            case "+":
                temp = Integer.parseInt(e1) + Integer.parseInt(e2);
                dequeue.addFirst(String.valueOf(temp));
                e1 = e2 = null;
                break;
            case "-":
                temp = Integer.parseInt(e1) - Integer.parseInt(e2);
                dequeue.addFirst(String.valueOf(temp));
                e1 = e2 = null;
                break;
            default:
                if (e1 == null) {
                    e1 = cur;
                }
                else if (e2 == null) {
                    e2 = cur;
                }
                if (dequeue.size() == 0) {
                    System.out.println(cur);
                    break;
                }
                break;
        }
    }
}

}

문제

정렬된 두 묶음의 숫자 카드가 있다고 하자. 각 묶음의 카드의 수를 A, B라 하면 보통 두 묶음을 합쳐서 하나로 만드는 데에는 A+B 번의 비교를 해야 한다. 이를테면, 20장의 숫자 카드 묶음과 30장의 숫자 카드 묶음을 합치려면 50번의 비교가 필요하다.

매우 많은 숫자 카드 묶음이 책상 위에 놓여 있다. 이들을 두 묶음씩 골라 서로 합쳐나간다면, 고르는 순서에 따라서 비교 횟수가 매우 달라진다. 예를 들어 10장, 20장, 40장의 묶음이 있다면 10장과 20장을 합친 뒤, 합친 30장 묶음과 40장을 합친다면 (10 + 20) + (30 + 40) = 100번의 비교가 필요하다. 그러나 10장과 40장을 합친 뒤, 합친 50장 묶음과 20장을 합친다면 (10 + 40) + (50 + 20) = 120 번의 비교가 필요하므로 덜 효율적인 방법이다.

N개의 숫자 카드 묶음의 각각의 크기가 주어질 때, 최소한 몇 번의 비교가 필요한지를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N이 주어진다. (1 ≤ N ≤ 100,000) 이어서 N개의 줄에 걸쳐 숫자 카드 묶음의 각각의 크기가 주어진다. 숫자 카드 묶음의 크기는 1,000보다 작거나 같은 양의 정수이다.

출력

첫째 줄에 최소 비교 횟수를 출력한다.

문제 풀이

문제 풀이 논리

• 비교 횟수가 점점 누적되어 더해지는 형태니까 적은 숫자 카드먼저 더하는게 유리하다!
• 처음에는 그래서 그냥 Array 로 정렬을 하고 앞에서부터 누적 덧셈을 해줬었다.. 근데 틀림! 만약에 맨 처음 20 25 30 35 50 이렇게 카드가 있다고 치면 중간에 20+25 = 45로 뒤에 더해지는 값인 35보다 커져서 이 경우에 20+25한 다음 30+35하고 나서 20+25인 45를 더하는게 더 비교 횟수가 적어진다.
• 따라서, Priority Queue를 사용해서 그때그때 가장 작은 숫자 두개를 먼저 더하는 형식으로 코드를 다시 짰다.

큐에서 숫자 뽑기 알고리즘

        //큐에서 가장 작은 숫자부터 뽑아서 계산
        int temp_sum = 0;
        int result = 0;
        while (pq.size() > 1) {
            temp_sum = pq.poll() + pq.poll();
            result = result + temp_sum;
            pq.add(temp_sum);
        }
        System.out.println(result);

• queue에 숫자가 하나밖에 없으면 비교할 게 더이상 없는 거니까 while문을 멈추고, 숫자가 남아 있으면 계속 연산을 진행한다.
• temp_sum에 맨 앞 두 개 숫자, 그니까 가장 작은 숫자 두 개를 뽑아서 더한 값을 넣는다.
• result는 모든 비교 횟수가 누적된 값이어야 하므로 한 번 루프가 돌 때마다 temp_sum을 계속해서 더해준다.
• pq에 현재 더한 값인 temp_sum을 넣어 위 논리에 적은, 앞의 두 값을 더한게 뒤 값보다 커지는 경우를 방지하고 비교할 수 있게 한다.
• 마지막에 result를 프린트하면 끝!

전체 코드

package Greedy;

import java.util.PriorityQueue;
import java.util.Scanner;

public class BOJ1715 {
    public static void main(String[] args) {
        //작은 숫자 뽑기 위해서 Integer형 priority queue 사용
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        //초기화 및 입력 받아 배열 채우기
        Scanner s = new Scanner(System.in);
        int N = s.nextInt();
        for (int i = 0; i < N; i++) {
            pq.add(s.nextInt());
        }

        //큐에서 가장 작은 숫자부터 뽑아서 계산
        int temp_sum = 0;
        int result = 0;
        while (pq.size() > 1) {
            temp_sum = pq.poll() + pq.poll();
            result = result + temp_sum;
            pq.add(temp_sum);
        }
        System.out.println(result);
    }
}

문제

인하은행에는 ATM이 1대밖에 없다. 지금 이 ATM앞에 N명의 사람들이 줄을 서있다. 사람은 1번부터 N번까지 번호가 매겨져 있으며, i번 사람이 돈을 인출하는데 걸리는 시간은 Pi분이다.

사람들이 줄을 서는 순서에 따라서, 돈을 인출하는데 필요한 시간의 합이 달라지게 된다. 예를 들어, 총 5명이 있고, P1 = 3, P2 = 1, P3 = 4, P4 = 3, P5 = 2 인 경우를 생각해보자. [1, 2, 3, 4, 5] 순서로 줄을 선다면, 1번 사람은 3분만에 돈을 뽑을 수 있다. 2번 사람은 1번 사람이 돈을 뽑을 때 까지 기다려야 하기 때문에, 3+1 = 4분이 걸리게 된다. 3번 사람은 1번, 2번 사람이 돈을 뽑을 때까지 기다려야 하기 때문에, 총 3+1+4 = 8분이 필요하게 된다. 4번 사람은 3+1+4+3 = 11분, 5번 사람은 3+1+4+3+2 = 13분이 걸리게 된다. 이 경우에 각 사람이 돈을 인출하는데 필요한 시간의 합은 3+4+8+11+13 = 39분이 된다.

줄을 [2, 5, 1, 4, 3] 순서로 줄을 서면, 2번 사람은 1분만에, 5번 사람은 1+2 = 3분, 1번 사람은 1+2+3 = 6분, 4번 사람은 1+2+3+3 = 9분, 3번 사람은 1+2+3+3+4 = 13분이 걸리게 된다. 각 사람이 돈을 인출하는데 필요한 시간의 합은 1+3+6+9+13 = 32분이다. 이 방법보다 더 필요한 시간의 합을 최소로 만들 수는 없다.

줄을 서 있는 사람의 수 N과 각 사람이 돈을 인출하는데 걸리는 시간 Pi가 주어졌을 때, 각 사람이 돈을 인출하는데 필요한 시간의 합의 최솟값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 사람의 수 N(1 ≤ N ≤ 1,000)이 주어진다. 둘째 줄에는 각 사람이 돈을 인출하는데 걸리는 시간 Pi가 주어진다. (1 ≤ Pi ≤ 1,000)

출력

첫째 줄에 각 사람이 돈을 인출하는데 필요한 시간의 합의 최솟값을 출력한다.

문제 풀이

그리디 알고리즘 이용

• 그리디 알고리즘이란, YOLO 같이 미래 생각 안하고 그때그때 최상인 것을 선택하는 알고리즘!
• 이 문제는 그리디가 자주 사용되는 스케줄링 문제!
• 시간이 짧은 순서대로 하면 최소 대기시간이 걸릴 것이라는게 문제에도 쓰여있다.

  그리디 알고리즘 작동 증명

  💡 그리디 알고리즘은 제대로 작동하는 경우가 정말 별로 없다..ㅎ.. 그래서 탐욕적 선택 속성, 최적 부분 구조를 만족하는지 항상 검토해야 한다. 💡 손으로 테스트 케이스 몇개 풀어보면 그리디의 감이 온다.. 스케줄링은 일단 그리디를 한번 부벼보자. 안되면 DP로 코드를 변경하면 됨!

1. 탐욕적 선택 속성 증명

💡 그리디 알고리즘을 선택했을 시, 손해가 발생하는지 점검한다.

1. 가장 적은 이용 시간을 가진 사람이 빠진 줄이 있다고 가정한다.
2. 맨 앞의 사람을 빼고 이 가장 적은 이용 시간을 가진 사람을 세운다.
3. 총 대기 시간이 더 짧아졌으면 짧아졌지 더 길어지지는 않는다.

• 그리디 알고리즘을 선택하는 것은 손해가 아님!

2. 최적 부분 구조 증명

💡 그리디한 답을 고르는 것이 부분 문제 해결 뿐만 아니라 최종 문제 해결까지 최적인지 검사한다.

1. 가장 이용 시간이 짧은 사람이 먼저 일을 처리한다고 가정한다.
2. 두 번째 대기하고 있는 사람은 가장 짧게 대기하고 일을 처리할 수 있다.
3. 대기 시간은 앞에서부터 계속 누적되는 구조니까 다 총 대기 시간은 짧아질 수밖에 없다.

   대기 시간 계산 로직

   소스 코드

     int temp = 0;
        int result = 0;
        for (int i = 1; i <= N; i++) {
            temp += people[i - 1];
            result += temp;
        }

• 맨 첫번째 사람은 대기하지 않으므로, i는 1부터 시작한다.
• 맨 마지막 사람도 대기 시간 계산에 포함해야 하므로, i는 N과 같아질 때도 연산에 포함한다.
• 대기 시간은 누적되는 구조이며, 앞 사람이 대기한 시간 + 바로 앞 사람이 업무 본 시간이 현재 사람이 대기하는 시간이며 temp에 저장한다.
• 총 대기시간인 result는 이 temp들을 모두 더한 값이므로 result += temp; 로 표기한다.

  최종 코드

  package Greedy;
  

import java.util.Arrays; import java.util.Scanner;

public class BOJ11399 { public static void main(String[] args) { //변수 선언 및 배열 값 넣기 Scanner s = new Scanner(System.in); int N = s.nextInt(); int[] people = new int[N]; for (int i = 0; i < N; i++) { people[i] = s.nextInt(); }

    //배열 작은 값부터 순서대로 정렬
    Arrays.sort(people);

    //기다린 시간 계산 - 누적으로 계산됨!
    int temp = 0;
    int result = 0;
    for (int i = 1; i <= N; i++) {
        temp += people[i - 1];
        result += temp;
    }
    System.out.println(result);
}

}

```

문제

10,000 이하의 자연수로 이루어진 길이 N짜리 수열이 주어진다. 이 수열에서 연속된 수들의 부분합 중에 그 합이 S 이상이 되는 것 중, 가장 짧은 것의 길이를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N (10 ≤ N < 100,000)과 S (0 < S ≤ 100,000,000)가 주어진다. 둘째 줄에는 수열이 주어진다. 수열의 각 원소는 공백으로 구분되어져 있으며, 10,000이하의 자연수이다.

출력

첫째 줄에 구하고자 하는 최소의 길이를 출력한다. 만일 그러한 합을 만드는 것이 불가능하다면 0을 출력하면 된다.

예제 입력 1

10 15 5 1 3 5 10 7 4 9 2 8

예제 출력 1

2

✍🏻 문제 풀이

적용 개념

시간 복잡도를 O(N)으로 줄이기 위해 투 포인터를 이용해서 풀었다.

투 포인터 개념

• 투 포인터는 부분합을 구할 때 유용하게 사용할 수 있는 개념인데, 배열의 시작 지점인 start와 끝 지점인 end를 명시해 합을 구하고 범위를 조절할 수 있도록 하는 방법이다.

  투 포인터 적용

• start를 증가시키는 경우 : 자연수의 배열이므로, 구해야하는 합보다 현재 구간 합이 크거나 같을 경우 start를 증가시켜서 다음 합을 찾음
• end를 증가시키는 경우 : 자연수의 배열이므로, 구해야하는 합보다 현재 구간 합이 작을 경우 증가시켜서 더하는 수를 늘림

  문제 적용

1. 이 문제에서는 S와 정확히 같은 경우가 아니라 S보다 크거나 같은 경우를 카운트 한다.
2. 따라서 S보다 크거나 같을 경우 구간의 길이를 재고, 다음 영역으로 옮기기 위해 start를 조정한다.
3. 어차피 길이 최소값을 구하는 거니까 S를 넘기만 하면 다음 구간으로 옮기면 됨!

💡 전체 코드

package TwoPointer;

import java.util.Scanner;

public class BOJ1806 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int start = 0;
        int end = 0;
        int N = s.nextInt();
        int S = s.nextInt();
        //초기화
        int[] numbers = new int[N];
        for (int i = 0; i < N; i++) {
            numbers[i] = s.nextInt();
        }
        //투 포인터 돌리기
        int length = Integer.MAX_VALUE;
        while (start < N && end < N) {
            int sum = 0;
            for (int i = start; i <= end; i++) {
                sum += numbers[i];
            }
            if (sum < S) {
                end++;
            } else {
                length = Math.min(length, end - start + 1);
                start++;
                if (end < start) {
                    end++;
                }
            }
        }
        System.out.println(length);
    }
}

시간복잡도가 안맞음,, 다시 바꿨다!

package TwoPointer;

import java.util.Scanner;

public class BOJ1806 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int start = 0;
        int end = 0;
        int N = s.nextInt();
        int S = s.nextInt();

        int[] numbers = new int[N];
        for (int i = 0; i < N; i++) {
            numbers[i] = s.nextInt();
        }

        int length = Integer.MAX_VALUE;
        int sum = 0;
        while(true){
            if (sum >= S) {
                length = Math.min(length, (end - start));
                sum -= numbers[start++];
            }
            else if (end == N) {
                break;
            }
            else {
                sum += numbers[end++];
            }
        }
        if (length == Integer.MAX_VALUE) {
            System.out.println(0);
        }
        else System.out.println(length);
    }
}

Oracle을 사용하는 이유

블록체인에서 데이터를 바로 끌어오는 것이 보안상 불가능하기때문에 오라클을 이용해 데이터를 끌어온다.

Oracle 통신 방식

Oracle 사용 구조 만들기

├── caller
│   ├── contracts
│   ├── migrations
│   ├── test
│   └── truffle-config.js
├── oracle
│   ├── contracts
│   ├── migrations
│   ├── test
│   └── truffle-config.js
└── package.json

오라클 통신

오라클 컨트랙트 부르기

caller 컨트랙트가 오라클과 통신하기 위해서는 인터페이스를 정의해야 한다.

인터페이스가 필요한 이유

• 인터페이스는 함수 선언만 한다
• 오라클과 통신하기 위해 반드시 정의 필요

  call 하기

1. FastFood라는 contract가 있다고 가정

   pragma solidity 0.5.0;
   

contract FastFood { function makeSandwich(string calldata _fillingA, string calldata _fillingB) external { //Make the sandwich } }

2. `FastFood` contract 부르는 `PrepareLunch` contract 만들고 인터페이스 정의하기
```js
pragma solidity 0.5.0;
//인터페이스 정의하기
//FastFood안에 있는 makeSandwich라는 함수가 컨트랙트를 부른다
interface FastFoodInterface {
   function makeSandwich(string calldata _fillingA, string calldata _fillingB) external;
}

3. 인터페이스를 인스턴스화하고 함수를 call 한다.

   pragma solidity 0.5.0;
   import "./FastFoodInterface.sol";
   

contract PrepareLunch {

FastFoodInterface private fastFoodInstance;

function instantiateFastFoodContract (address _address) public { fastFoodInstance = FastFoodInterface(_address); fastFoodInstance.makeSandwich("sliced ham", "pickled veggies"); } }

# Mapping을 req 기록으로 사용하기
## 이더 가격 업데이트 하기
- 오라클에서 이더리움 가격 끌어오려면 `getLatestEthPrice()` 를 작동시켜야 한다. 
- 하지만 이 작업이 비동기적으로 일어나서 이건 유니크한 `id`만 리턴한다.
- 대신에 `callback`함수가 이더 가격을 업데이트해준다.
## map으로 callback 검사하기
```js
//맵핑 정의
mapping(address => uint) public balances;
//msg.sender == address
balances[msg.sender] = someNewValue

• uint 값은 맨 처음에 0 으로 초기화된다.
• 새로 받은 값을 이렇게 맵으로 저장!

  callback 함수의 역할

  callback 함수 작동 순서

1. 함수가 인증된 id 로 부터 호출되었는지 require써서 검사
2. 인증된 id일 경우 myRequests 맵핑에서 제거
3. 프론트엔드에게 이더 가격이 변동되었다고 알림 날림

   오라클 인증

   인증된 주소인지 검사하기

• 오라클의 주소를 담은 변수를 이용해서 확인한다.
• 함수를 부른 곳의 주소가 이 오라클 주소인지를 확인하면 된다.
• 솔리디티의 msg.sender 를 이용해서 검사한다.

    modifier onlyOracle() {
      require(msg.sender==oracleAddress, "You are not authorized to call this function.");
      _;
    }

• 뒤의 구문은 만약 아닐 경우 나는 오류 메세지

  오라클 컨트랙트

  오라클 컨트랙트의 목적

• caller contract가 이더 가격 피드에 접근할 수 있게 해주는 다리같은 역할을 한다.
• getLatestEthPrice() 와 setLatestEthPrice() 두 개를 implement 해서 사용한다.

  getLatestEthPrice()

• 오라클은 맨 처음 request id 를 계산한다.
• 이 request id 는 보안상의 이유로 계산하기 힘들게 만들어야 한다.

  uint randNonce = 0;
  uint modulus = 1000;
  uint randomNumber = uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % modulus;
  

- 위 코드처럼 `keccak256`으로 랜덤 넘버를 생성한다.
```js
function getLatestEthPrice() public returns (uint256) {
    randNonce++;
    uint id = uint(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % modulus;
  //리퀘스트 트래킹
    pendingRequests[id] = true;
  //이벤트가 발생했음을 알려줌
    emit GetLatestEthPriceEvent(msg.sender, id);
  //id 리턴
    return id;
  }

• 리퀘스트 트래킹하는 시스템을 매핑으로 만들 수 있다.
• 마지막에 이벤트가 발생했음을 알려줘야 함
• request id 를 return해야 함

  setLatestEthPrice()

  함수 설명

• 위에서 이더 가격을 받고 setLatestEthPrice()함수를 불러서 아래 세 가지를 인자로 넘겨준다

1. 이더 가격
2. 리퀘스트를 시작한 컨트랙트의 주소
3. 리퀘스트의 아이디

   function setLatestEthPrice(uint256 _ethPrice, address _callerAddress,   uint256 _id) public onlyOwner {
    require(pendingRequests[_id], "This request is not in my pending list.");
    delete pendingRequests[_id];
   }

• 리퀘스트 아이디가 true 인지 확인힌다.(==true 안해도 저 자체가 boolean이라 pendingRequests[_id]만 사용)
• 넘겨받으면 pendingRequests에서 해당 아이디 기록을 지워야 한다.

  인터페이스를 이용해 callback 작동시킴

  function setLatestEthPrice(
        uint256 _ethPrice,
        address _callerAddress,
        uint256 _id
    ) public onlyOwner {
        require(
            pendingRequests[_id],
            "This request is not in my pending list."
        );
        delete pendingRequests[_id];
          //컨트랙트 인스턴스화
        CallerContracInterface callerContractInstance;
        callerContractInstance = CallerContracInterface(_callerAddress);
          //콜백 함수 작동시킴
        callerContractInstance.callback(_ethPrice, _id);
          //이벤트 트리거
        emit SetLatestEthPriceEvent(_ethPrice, _callerAddress);
    }

• 컨트랙트의 인터페이스를 인스턴스화시킴
• 인스턴스화된 컨트랙트의 callback함수를 작동시켜 이더리움 가격과 리퀘스트의 아이디를 넘긴다.

트러플을 사용하는 이유

1. 쉬운 스마트 컨트랙트 연결
2. 자동화된 ABI 만들기
3. 스마트 컨트랙트 테스팅이 합쳐져 있음(chai랑 Mocha도 지원)
4. 여러 네트워크 지원

   트러플 기본 구조

   기본으로 설치되는 tree 구조

   ├── contracts
    ├── Migrations.sol
   ├── migrations
    ├── 1_initial_migration.js
   └── test
   truffle-config.js
   truffle.js

• truffle init 명령어를 실행하면 위와 같은 기본 구조가 설치된다.

  구조 설명

• contracts : 트러플이 내가 만든 컨트랙트를 찾는 곳. 보통 contracts/tokens 처럼 nested로 정리한다.

• migrations : 트러플에게 어떻게 스마트 컨트랙트를 배포할지 말하는 자바스크립트 파일이 위치

• test : 유닛 테스트 파일을 넣는 곳

• truffle.js : 네트워크 세팅을 저장하는 곳

• truffle.config.js : 윈도우 쓰면 truffle.js 지우고 이걸 config 파일로 사용해야 한다.

  truffle-hdwallet-provider

  트랜잭션 sign을 하기 위해 설치하는 프로바이더! 보통 truffle init 하고 바로 설치함!

• 우리는 Infura 를 사용해서 이더리움에 코드를 배포할 것이다.

• Infura 를 쓰면 이더리움 노드나 지갑을 직접 run 할 필요가 없다.

• 하지만 인퓨라의 경우 프라이빗 키를 제공하지 않아서 트랜잭션을 직접 시작할 수 없다.

• 그래서 트랜잭션을 시작할 수 있는 truffle-hdwallet-provider를 따로 설치해서 이용한다.

  Compiler

  컴파일러를 사용하는 이유

• 이더리움 가상 머신은 솔리디티로 작성된 코드를 바로 이해하지 못한다.

• 따라서 머신이 읽을 수 있도록 컴파일 하는 것이 필요하다.

  스마트 컨트랙트 컴파일 하기

  ├── contracts
    ├── Migrations.sol
    ├── CryptoZombies.sol
    ├── erc721.sol
    ├── ownable.sol
    ├── safemath.sol
    ├── zombieattack.sol
    ├── zombiefactory.sol
    ├── zombiefeeding.sol
    ├── zombiehelper.sol
    ├── zombieownership.sol
  ├── migrations
  └── test

• 스마트 컨트랙트 코드를 contracts 안에 넣고 컴파일 진행

로컬 테스트

Ganache 이용 로컬 테스트 - migrations

새 migration 만들기

var Migrations = artifacts.require("./Migrations.sol");
module.exports = function(deployer) {
  deployer.deploy(Migrations);
};

1. 이 스크립트는 트러플에게 우리가 migration 컨트랙트와 통신하기를 원한다는 것을 알려준다
2. 이 스크립트는 deployer라는 객체를 받는 함수를 export한다

• 여기서 deployer라는 객체는 개발자와 프러플의 개발 엔진 간의 인터렉션을 담당한다.

  내 앱에 맞게 migrations 수정하기

  var CryptoZombies = artifacts.require("./CryptoZombies.sol");
  module.exports = function(deployer) {
  deployer.deploy(CryptoZombies);
  };

• 내 앱에 맞게 변수 이름 수정하기!

  Testnet 이용 - Rinkeby

  Config 파일 수정으로 네트워크 이용 설정하기

  아래 코드는 메인넷과 rinkeby 의 config 객체 두개에 대한 설정을 담고있다.

networks: {
  // Configuration for mainnet
  mainnet: {
    provider: function () {
      // Setting the provider with the Infura Rinkeby address and Token
      return new HDWalletProvider(mnemonic, "https://mainnet.infura.io/v3/YOUR_TOKEN")
    },
    network_id: "1"
  },
  // Configuration for rinkeby network
  rinkeby: {
    // Special function to setup the provider
    provider: function () {
      // Setting the provider with the Infura Rinkeby address and Token
      return new HDWalletProvider(mnemonic, "https://rinkeby.infura.io/v3/YOUR_TOKEN")
    },
    // Network id is 4 for Rinkeby
    network_id: 4
  }

• 트러플에게 메인넷을 알려준다.
• 트러플에게 rinkeby 를 사용할거라고 알려준다.

  config 파일 전체 모습

  // Initialize HDWalletProvider
  const HDWalletProvider = require("truffle-hdwallet-provider");
  

// Set your own mnemonic here const mnemonic = "YOUR_MNEMONIC";

// Module exports to make this configuration available to Truffle itself module.exports = { // Object with configuration for each network networks: { // Configuration for mainnet mainnet: { provider: function () { // Setting the provider with the Infura Rinkeby address and Token return new HDWalletProvider(mnemonic, "https://mainnet.infura.io/v3/YOUR_TOKEN") }, network_id: "1" }, // Configuration for rinkeby network rinkeby: { // Special function to setup the provider provider: function () { // Setting the provider with the Infura Rinkeby address and Token return new HDWalletProvider(mnemonic, "https://rinkeby.infura.io/v3/YOUR_TOKEN") }, // Network id is 4 for Rinkeby network_id: 4 } } };

## Faucet으로 이더 받기
https://faucet.rinkeby.io/
- 위 링크에서 주소로 이더 받기 가능!
## migrate 실행
![](https://images.velog.io/images/dandev_sw/post/c56f5a7d-d1e5-4af5-ad84-45c7bc7a9bca/%E1%84%89%E1%85%B3%E1%84%8F%E1%85%B3%E1%84%85%E1%85%B5%E1%86%AB%E1%84%89%E1%85%A3%E1%86%BA%202021-03-06%20%E1%84%8B%E1%85%A9%E1%84%92%E1%85%AE%203.42.32.png)
- 위 처럼 `truffle migrate --network rinkeby` 명령어로 실행

프로젝트 구조

트러플을 사용해 빌드한 프로젝트 구조는 다음과 같이 된다.

├── build
  ├── contracts
      ├── Migrations.json
      ├── CryptoZombies.json
      ├── erc721.json
      ├── ownable.json
      ├── safemath.json
      ├── zombieattack.json
      ├── zombiefactory.json
      ├── zombiefeeding.json
      ├── zombiehelper.json
      ├── zombieownership.json
├── contracts
  ├── Migrations.sol
  ├── CryptoZombies.sol
  ├── erc721.sol
  ├── ownable.sol
  ├── safemath.sol
  ├── zombieattack.sol
  ├── zombiefactory.sol
  ├── zombiefeeding.sol
  ├── zombiehelper.sol
  ├── zombieownership.sol
├── migrations
└── test
. package-lock.json
. truffle-config.js
. truffle.js

• test 폴더에 주목!

  트러플 특징

• 언어는 javascript와 solidity를 지원한다.
• 이 튜토리얼에서는 간편한 작성을 위해 javascript로 코드를 짤 예정

테스트 코드 주의할 점

• 테스트 코드를 짤 때에는 한 컨트랙트 당 하나의 테스트를 짜야 유지 보수에 좋다!

빌드

빌드 생성물

• 스마트 컨트랙트를 빌드할 때 솔리디티 컴파일러는 자동으로 JSON 형식의 파일을 생성한다.
• 이 파일 속에는 컨트랙트의 binary representation이 들어있다.
• 빌드하면서 나온 JSON 파일은 build/contracts 폴더에 저장된다.

  빌드 생성물 가져오기

  const myAwesomeContract = artifacts.require(“myAwesomeContract”);

• 이 코드는 컨트랙트 abstraction을 리턴한다.
• 말 그대로 abstraction 이라서 뒤에서 자바스크립트 객체를 생성해서 그거로 컨트랙트와 통신해야한다.

  Contract 함수

  테스트를 단순하게 만들기 위해 Truffle은 Mocha안에 얇은 wrapper를 만든다.

  그룹 테스트

• contract()함수를 불러서 실행하고, 이건 mocha의 describe함수에 테스팅 어카운트 리스트를 제공하고 정리 좀 해주고 extends 한다.
• contract()함수는 두개의 인자를 받는다. 어떤 것을 테스트할지 보여주는 string과 테스트를 write하는 장소를 보여주는 callback()

  it()으로 테스트 실행하기

• it()이라는 함수를 불러서 테스트를 실행한다.
• 이것도 맨 처음에 어떤 것을 테스트할지 나타내는 string과 테스트 장소를 나타내는callback()으로 이루어져있다.

  최종 테스트 코드

  contract("MyAwesomeContract", (accounts) => {
   it("should be able to receive Ethers", await () => {
   })
  })

• 이건 contract의 callback()에서 it()을 부르는 형태
• 자바스크립트 비동기적이니까 await써서 it()함수 사용

  로컬 테스트

  Ganache

• 이더리움에 배포하기 전에 로컬 환경에서 스마트 컨트랙트를 테스트 해봐야 한다. Ganache라는 툴은 로컬 이더리움 네트워크를 셋업해준다.
• Ganache는 시작할 때마다 10개의 테스트 어카운트를 만들고 각각 100이더를 지급한다.
• Ganache와 Truffle은 잘 연동되어 있어서 우리는 accounts라는 배열로 어카운트에 접근할 수 있다.

  접근하기

• account[0], account[1]같은 것은 테스트 시 읽기가 매우 불편하다. 그래서 contract() 함수 안에서 아래처럼 initialize 해서 쓴다.

  let [alice, bob] = accounts;

  테스트 순서

  Set up

• initial state와 input을 define한다.

  js 인스턴스와 abstraction 만들어서 테스트하기

  const contractInstance = await myAwesomeContract.new();

• 위에서 만든 abstraction인 myAwesomeContract을 이용하여 실제 컨트랙트 통신에 이용할 수 있는 자바스크립트 인스턴스를 만든다.

//좀비 array를 글로벌로 선언하고
const zombieNames = ["Zombie #1", "Zombie #2"];

//아래처럼 좀비를 이용해 컨트랙트의 메소드를 실행할 수 있다.
//createRandomZombie는 좀비 객체를 받는 함수였을 것..
contractInstance.createRandomZombie(zombieNames[0]);

• 자바스크립트 객체를 만든 후에 메소드를 이용하는 형식!

  act

• 실제로 코드를 테스트 하는 공간!
• 항상 하나의 로직만 테스트하도록 해야한다

  Truffle 내장 기능 이용해서 address지정하기

  const result = await contractInstance.createRandomZombie(zombieNames[0], {from: alice});

• Setup 부분 코드의 문제점은 좀비를 보내는 주소를 지정하지 못한다는 것이었다.
• Truffle에서는 솔리디티의 주소 체계를 가져와서 이용할 수 있다. 따라서 createRandomZombie 함수에 {from: alice}를 넣어 msg.sender가 address를 set할 수 있도록 한다.

  artifacts.require 이용

• 트러플에서 제공하는 artifacts.require을 사용하면 result.logs[0].args.name 같이 이용할 수 있다.

  result에는 무엇이 저장될까?

• result.tx: 트랜잭션 해시값
• result.receipt: 트랜잭션 영수증을 포함하는 object
• result.receipt.status: true일 경우 트랜잭션 성공, 아닐경우 false를 리턴

  assert

• 결과물을 체크하는 공간

  내장된 라이브러리 사용

• equal(), deepEqual() 같이 빌트인된 assertion 을 이용한다.
• assert.equal() 이런 식으로 사용!

  최종 코드

  it("should be able to create a new zombie", async () => {
   //앞에 만든 abstraction으로 instance를 생성해서 사용
        const contractInstance = await CryptoZombies.new();
   //await으로 result에 반드시 값이 들어오도록 설정
        const result = await contractInstance.createRandomZombie(zombieNames[0], {from: alice});
   //영수증 받은거 맞는지 확인
        assert.equal(result.receipt.status, true);
   //좀비 이름이 같은지 확인
        assert.equal(result.logs[0].args.name,zombieNames[0]);
    })

  Hooks

  test 환경 자동설정

• 테스트를 할 때마다 새롭게 인스턴스를 생성해야 하는데, Truffle에서는 이걸 beforeEach() 함수로 자동으로 설정해준다.

  beforeEach(async () => {
  // let's put here the code that creates a new contract instance
  });
  

- `contract.new()` 대신에 `beforeEach()` 한 번이면 뚝딱 해결

## beforEach()로 매번 생성? 매번 삭제는 afterEach()
```js
//컨트랙트 삭제하는 kill 함수 정의
function kill() public onlyOwner {
   selfdestruct(owner());
}

//매번 실행이 끝날 때마다 컨트랙트를 kill
afterEach(async () => {
   await contractInstance.kill();
});

• 블록체인 테스트서버 과부하를 막기 위해 테스트가 끝난 후 kill해서 컨트랙트를 destruct한다!

  error 잡기

  try {
    //try to create the second zombie
    await contractInstance.createRandomZombie(zombieNames[1], {from: alice});
    assert(true);
  }
  catch (err) {
    return;
  }
  assert(false, "The contract did not throw.");

• try-catch 사용해서 에러가 났을 때 에러 잡음!
• 여기서 에러 나는 이유는 앨리스가 이미 좀비를 가지고 있는데 또 다른 좀비를 create 했기 때문이다.
• 보통 이 에러 잡는 구문은 따로 분리해 helpers/utils에 적고 import 해온다.

  Account 간 통신 test

  ERC721 토큰 통신 방식

1. owner 가 transferFrom()을 불러 receiver에게 토큰 전달

   function transferFrom(address _from, address _to, uint256 _tokenId) external payable;

2. owner 가 approve를 부르고 owner나 receiver가 transferForm()을 보내는 형식

   //approve 부르기
   function approve(address _approved, uint256 _tokenId) external payable;
   

//transferForm 부르기 function transferFrom(address _from, address _to, uint256 _tokenId) external payable;

- `approve`를 부르면 컨트랙트가 트랜잭션 정보(address)를 저장한다.
- `transferForm`을 부르면 자동으로 `msg.sender`가 `owner`나 `receiver`의 주소와 일치하는지를 검사한다. 
- 일치한다면 토큰을 보낸다.
## Truffle이 제공하는 context() 이용
### 1번 케이스 테스트 코드
```js
context("with the single-step transfer scenario", async () => {
    it("should transfer a zombie", async () => {
      // TODO: Test the single-step transfer scenario.
      //랜덤 좀비 생성 코드
      const result = await contractInstance.createRandomZombie(zombieNames[0], {from: alice});
      //좀비 아이디가 로그에 찍힌 좀비 아이디와 같은지 확인
            const zombieId = result.logs[0].args.zombieId.toNumber();
            await contractInstance.transferFrom(alice, bob, zombieId, {from: alice});
      //새로운 주인이 bob이 되었는지 확인
            const newOwner = await contractInstance.ownerOf(zombieId);
            assert.equal(newOwner, bob);
    })
})

2번 케이스 테스트 코드

 context("with the two-step transfer scenario", async () => {
   //alice가 transferFrom을 부름
        it("should approve and then transfer a zombie when the approved address calls transferFrom", async () => {
            const result = await contractInstance.createRandomZombie(zombieNames[0], {from: alice});
            const zombieId = result.logs[0].args.zombieId.toNumber();
            await contractInstance.approve(bob, zombieId, {from: alice});
            await contractInstance.transferFrom(alice, bob, zombieId, {from: bob});
            const newOwner = await contractInstance.ownerOf(zombieId);
            assert.equal(newOwner,bob);
        })
   //bob이 transferForm을 부름
        it("should approve and then transfer a zombie when the owner calls transferFrom", async () => {
            const result = await contractInstance.createRandomZombie(zombieNames[0], {from: alice});
            const zombieId = result.logs[0].args.zombieId.toNumber();
            await contractInstance.approve(bob, zombieId, {from: alice});
            await contractInstance.transferFrom(alice, bob, zombieId, {from: alice});
            const newOwner = await contractInstance.ownerOf(zombieId);
            assert.equal(newOwner,bob);
         })
    })

• 위 테스트코드는 항상 모든 테스트를 검사함..
• 따라서 아래처럼 x를 붙여 트러플이 검사를 스킵할 수 있도록 조정

//context 앞에 x
xcontext("with the single-step transfer scenario", async () => {
    it("should transfer a zombie", async () => {
      // TODO: Test the single-step transfer scenario.
    })
})
//it 앞에 x
context("with the single-step transfer scenario", async () => {
    xit("should transfer a zombie", async () => {
      // TODO: Test the single-step transfer scenario.
    })
})

테스트 결과

Contract: CryptoZombies
    ✓ should be able to create a new zombie (199ms)
    ✓ should not allow two zombies (175ms)
    with the single-step transfer scenario
      - should transfer a zombie
    with the two-step transfer scenario
      - should approve and then transfer a zombie when the owner calls transferFrom
      - should approve and then transfer a zombie when the approved address calls transferFrom


  2 passing (827ms)
  3 pending

Time traveling

이전 좀비 게임 test 문제점 - coolDown

function _createZombie(string _name, uint _dna) internal {
  uint id = zombies.push(Zombie(_name, _dna, 1, uint32(now + cooldownTime), 0, 0)) - 1;
  zombieToOwner[id] = msg.sender;
  ownerZombieCount[msg.sender] = ownerZombieCount[msg.sender].add(1);
  emit NewZombie(id, _name, _dna);
}

• coolDown 시간 설정 때문에 한 번 좀비를 생성하면 하루동안 생성이 안됨.. 그래서 테스트 코드를 여러번 돌려볼 수 없음
• 그래서 time traveling을 적용!

  Ganache의 시간 여행 함수

  시간 조정 함수 두 가지

1. evm_increaseTime: 다음 블럭의 시간을 increase
2. evm_mine: 새로운 블록을 mine

   함수가 작동하는 원리

• 새로운 블록이 채굴될 때마다 채굴자는 타임스탬프를 블록에 넣는다.
• evm_increaseTime을 작동시킨다. 블록체인은 이미 기록된 블록은 변할 수가 없으니 당장 시간에는 아무 변화가 없고, 대신 다음 채굴되는 블록의 시간을 변화시킨다.
• evm_mine을 통해 블록을 채굴하면 시간이 앞으로 당겨져있는 것을 볼 수 있다.

  time travel 코드

  await web3.currentProvider.sendAsync({
  jsonrpc: "2.0",
  method: "evm_increaseTime",
  params: [86400],  // there are 86400 seconds in a day
  id: new Date().getTime()
  }, () => { });
  

web3.currentProvider.send({ jsonrpc: '2.0', method: 'evm_mine', params: [], id: new Date().getTime() });

- 이건 `helper` 쪽으로 빼서 작성해놓는다.

### 가져와서 이용하는 코드
```js
await time.increase(time.duration.days(1))

• time 임포트해와서 가져다가 사용!

  트러플에서 돌려보면?

  Contract: CryptoZombies
    ✓ should be able to create a new zombie (119ms)
    ✓ should not allow two zombies (112ms)
    ✓ should return the correct owner (109ms)
    ✓ zombies should be able to attack another zombie (475ms)
    with the single-step transfer scenario
      ✓ should transfer a zombie (235ms)
    with the two-step transfer scenario
      ✓ should approve and then transfer a zombie when the owner calls transferFrom (181ms)
      ✓ should approve and then transfer a zombie when the approved address calls transferFrom (152ms)

  Chai를 이용한 assertion

  위의 assertion은 읽기가 힘들어서 chai의 assertion 모듈을 많이 따다가 쓴다!

Chai의 세 가지 Assertion type

That said, let's take a look at the three kinds of assertion styles bundled into Chai:

1. expect: 체인의 natural language assertions 을 다음과 같이 제공한다.

   let lessonTitle = "Testing Smart Contracts with Truffle";
   expect(lessonTitle).to.be.a("string");

2. should: should 로 시작하고 인터페이스와 비슷한 assertion을 제공한다.

   let lessonTitle = "Testing Smart Contracts with Truffle";
   lessonTitle.should.be.a("string");

3. assert: notation 을 제공하고 브라우저에서 작동할 수 있는 추가적인 테스트를 제공한다.

   let lessonTitle = "Testing Smart Contracts with Truffle";
   assert.typeOf(lessonTitle, "string");

   expect().to.equal()

let zombieName = 'My Awesome Zombie';
expect(zombieName).to.equal('My Awesome Zombie');

• assertion들을 위 코드처럼 chai 문법으로 바꾸어 사용한다!

Loom에서 테스트하기

• 위 코드를 고칠 필요 없이 바로 사용할 수 있음

  Loom network object

    loom_testnet: {
      provider: function() {
        const privateKey = 'YOUR_PRIVATE_KEY';
        const chainId = 'extdev-plasma-us1';
        const writeUrl = 'wss://extdev-basechain-us1.dappchains.com/websocket';
        const readUrl = 'wss://extdev-basechain-us1.dappchains.com/queryws';
        return new LoomTruffleProvider(chainId, writeUrl, readUrl, privateKey);
      },
      network_id: 'extdev'
    }

  트러플과 Loom 통신

  truffle.js

  const HDWalletProvider = require("truffle-hdwallet-provider");
  const LoomTruffleProvider = require('loom-truffle-provider');
  const mnemonic = "YOUR MNEMONIC HERE";
  module.exports = {
    // Object with configuration for each network
    networks: {
        //development
        development: {
            host: "127.0.0.1",
            port: 7545,
            network_id: "*",
            gas: 9500000
        },
        // Configuration for Ethereum Mainnet
        mainnet: {
            provider: function() {
                return new HDWalletProvider(mnemonic, "https://mainnet.infura.io/v3/<YOUR_INFURA_API_KEY>")
            },
            network_id: "1" // Match any network id
        },
        // Configuration for Rinkeby Metwork
        rinkeby: {
            provider: function() {
                // Setting the provider with the Infura Rinkeby address and Token
                return new HDWalletProvider(mnemonic, "https://rinkeby.infura.io/v3/<YOUR_INFURA_API_KEY>")
            },
            network_id: 4
        },
        // Configuration for Loom Testnet
        loom_testnet: {
            provider: function() {
                const privateKey = 'YOUR_PRIVATE_KEY';
                const chainId = 'extdev-plasma-us1';
                const writeUrl = 'wss://extdev-basechain-us1.dappchains.com/websocket';
                const readUrl = 'wss://extdev-basechain-us1.dappchains.com/queryws';
                // TODO: Replace the line below
                return new LoomTruffleProvider(chainId, writeUrl, readUrl, privateKey);
            },
            network_id: '9545242630824'
        }
    },
    compilers: {
        solc: {
            version: "0.4.25"
        }
    }
  };

  LoomProvider 이용

• 현재 디폴트로 사용하고 있는 HDWallet대신 LoomProvider를 이용하고, 프로바이더로 account 정보를 보내야 한다.

  return new LoomTruffleProvider(chainId, writeUrl, readUrl, privateKey)

• 이 코드를 아래처럼 바꾸어야 돌아감!

  const loomTruffleProvider = new LoomTruffleProvider(chainId, writeUrl, readUrl, privateKey);
  loomTruffleProvider.createExtraAccountsFromMnemonic(mnemonic, 10);
  return loomTruffleProvider;

문제 해석

문제

어떤 N개의 수가 주어져 있다. 그런데 중간에 수의 변경이 빈번히 일어나고 그 중간에 어떤 부분의 합을 구하려 한다. 만약에 1,2,3,4,5 라는 수가 있고, 3번째 수를 6으로 바꾸고 2번째부터 5번째까지 합을 구하라고 한다면 17을 출력하면 되는 것이다. 그리고 그 상태에서 다섯 번째 수를 2로 바꾸고 3번째부터 5번째까지 합을 구하라고 한다면 12가 될 것이다.

입력

첫째 줄에 수의 개수 N(1 ≤ N ≤ 1,000,000)과 M(1 ≤ M ≤ 10,000), K(1 ≤ K ≤ 10,000) 가 주어진다. M은 수의 변경이 일어나는 횟수이고, K는 구간의 합을 구하는 횟수이다. 그리고 둘째 줄부터 N+1번째 줄까지 N개의 수가 주어진다. 그리고 N+2번째 줄부터 N+M+K+1번째 줄까지 세 개의 정수 a, b, c가 주어지는데, a가 1인 경우 b(1 ≤ b ≤ N)번째 수를 c로 바꾸고 a가 2인 경우에는 b(1 ≤ b ≤ N)번째 수부터 c(b ≤ c ≤ N)번째 수까지의 합을 구하여 출력하면 된다.

입력으로 주어지는 모든 수는 -263보다 크거나 같고, 263-1보다 작거나 같은 정수이다.

출력

첫째 줄부터 K줄에 걸쳐 구한 구간의 합을 출력한다. 단, 정답은 -263보다 크거나 같고, 263-1보다 작거나 같은 정수이다.

문제 풀이

👊🏻 무식하게 풀기

풀이 과정

문제 자체는 단순한 편이나, 입력이 엄청 큰 문제였다. 일단 무식하게 풀기는 그냥 문제에서 하라는대로 풀었고, 특별한 자료구조를 사용하지 않고 그냥 배열을 이용했다.

1. 입력을 받아 숫자를 배열에 저장한다.
2. a가 1일 경우 문제에서 하라는 대로 배열의 위치를 바꾼다.
3. a가 2일 경우 문제에서 하라는 대로 구간합을 구해 출력한다.

   풀이 코드

   package Tree;
   

import java.util.Scanner;

public class BOJ2042 { static int[] numbers; public static void main(String[] args) { Scanner s = new Scanner(System.in); int N = s.nextInt(); int M = s.nextInt(); int K = s.nextInt(); numbers = new int[N+1]; for (int i = 1; i < N+1; i++) { numbers[i] = s.nextInt(); } for (int i = 0; i < M+K; i++) { int a = s.nextInt(); int b = s.nextInt(); int c = s.nextInt(); sum(a, b, c); } }

static void sum(int a, int b, int c) {
    if(a==1){
        numbers[b] = c;
    }
    else if(a==2){
        int result = 0;
        for (int i = b; i <= c; i++) {
            result = result + numbers[i];
        }
        System.out.println(result);
    }
}

}

### 무식한 풀이 결과
![](https://images.velog.io/images/dandev_sw/post/2d0378fd-c4c3-43b3-bb31-54db09bad35d/image.png)
- 결과는 예상대로 `시간 초과`.. 
- 코드 뚝딱 2분컷 해서 억울하지는 않아요..아..
- 담담한척 하지만 사실 많이 슬펐다.. 진짜 `트리`를 써야하나..?! `DP`로 풀어볼까..? 고민했다.. 근데 트리 문제 야매로 푸는거 자꾸 버릇들어서 버릇을 고쳐보기로함..!
## 🌲 세그먼트 트리로 풀기

Web3.js란?

이더리움 네트워크는 노드로 구성되어 있고, 각 노드는 블록체인의 복사본을 가지고 있다. 스마트 컨트랙트의 함수를 실행하고자 한다면, 이 노드들 중 하나에 질의를 보내 아래 내용을 전달해야 한다.

1. 스마트 컨트랙트의 주소
2. 실행하고자 하는 함수
3. 그 함수에 전달하고자 하는 변수

이더리움 노드들은 JSON-RPC라고 불리는 언어로만 소통한다.

퀴리는 아래와 같이 생겼다.

{"jsonrpc":"2.0","method":"eth_sendTransaction","params":[{"from":"0xb60e8dd61c5d32be8058bb8eb970870f07233155","to":"0xd46e8dd67c5d32be8058bb8eb970870f07244567","gas":"0x76c0","gasPrice":"0x9184e72a000","value":"0x9184e72a","data":"0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"}],"id":1}

다행히도, Web3.js 편리하고 쉽게 읽을 수 있는 자바스크립트 인터페이스로 이를 전달할 수 있게 해준다.

위의 쿼리 대신 아래와 같이 코드에서 함수를 호출할 수 있다.

CryptoZombies.methods.createRandomZombie("Vitalik Nakamoto 🤔")
  .send({ from: "0xb60e8dd61c5d32be8058bb8eb970870f07233155", gas: "3000000" })

Web3 프로바이더

우리가 처음 필요로 하는 것은 Web3 프로바이더(Provider)이다.

• 이더리움은 똑같은 데이터의 복사본을 공유하는 노드들로 구성되어 있다. Web3.js에서 Web3 프로바이더를 설정하는 것은 코드에 읽기와 쓰기를 처리하려면 어떤 노드와 통신을 해야 하는지를 설정하는 과정이다.
• 이는 전통적인 웹 앱에서 API 호출을 위해 원격 웹 서버의 URL을 설정하는 것과 같다.

Infura - 간편한 프로바이더

Infura는 빠른 읽기를 위한 캐시 계층을 포함하는 다수의 이더리움 노드를 운영하는 서비스이다. Infura를 프로바이더로 사용하면, 자네만의 이더리움을 설치하고 계속 유지할 필요 없이 이더리움 블록체인과 메세지를 확실히 주고받을 수 있다.

다음과 같이 Web3에 Web3 프로바이더로 Infura를 쓰도록 설정할 수 있다.

var web3 = new Web3(new Web3.providers.WebsocketProvider("wss://mainnet.infura.io/ws"));

하지만, 많은 사용자들이 DApp에 읽고 쓰기 연산을 할 것이니, 이 사용자들이 개인 키를 사용해 트랜잭션에 서명을 하는 과정을 추가해야 한다.

💊 참고: 이더리움(그리고 일반적으로 블록체인)은 트랜잭션에 전자 서명을 하기 위해 공개/개인 키 쌍을 사용한다. 만약 블록체인에서 어떤 데이터를 변경하면, 나의 공개 키를 통해 내가 거기 서명을 한 사람이라고 증명할 수 있다 - 하지만 아무도 내 개인 키를 모르기 때문에, 내 트랜잭션을 누구도 위조할 수 없다.

메타마스크(Metamask) - 사용자 개인키 관리

메타마스크의 정의

메타마스크는 사용자들이 이더리움 계정과 개인 키를 안전하게 관리할 수 있게 해주는 크롬과 파이어폭스의 브라우저 확장 프로그램이다. 그리고 해당 계정들을 써서 Web3.js를 사용하는 웹사이트들과 상호작용을 할 수 있도록 해준다.

디앱을 메타마스크와 호환한다면, 디앱 사용자들은 웹에서도 자유롭게 디앱 서비스를 이용할 수 있다.

💊 참고: 메타마스크는 내부적으로 Infura의 서버를 Web3 프로바이더로 사용한다. 하지만 사용자들에게 그들만의 Web3 프로바이더를 선택할 수 있는 옵션을 주기도 한다. 즉 메타마스크의 Web3 프로바이더를 사용하면, 사용자에게 선택권을 주는 것이기도 하면서 앱의 개인 키 문제도 해결할 수 있다.

메타마스크의 Web3 프로바이더 사용하기

메타마스크는 web3라는 전역 자바스크립트 객체를 통해 브라우저에 Web3 프로바이더를 주입하네. 그러므로 앱에서는 web3가 존재하는지 확인하고, 만약 존재한다면 web3.currentProvider를 프로바이더로서 사용하면 된다.

아래는 메타마스크에서 제공하는 코드이다. 사용자가 메타마스크를 설치했는지 확인하고 설치가 안 된 경우 우리 앱을 사용하려면 메타마스크를 설치해야 한다고 알려주는 코드!

window.addEventListener('load', function() {

  // Web3가 브라우저에 주입되었는지 확인(Mist/MetaMask)
  if (typeof web3 !== 'undefined') {
    // Mist/MetaMask의 프로바이더 사용
    web3js = new Web3(web3.currentProvider);
  } else {
    // 사용자가 Metamask를 설치하지 않은 경우에 대해 처리
    // 사용자들에게 Metamask를 설치하라는 등의 메세지를 보여줄 것
  }

  // 이제 앱을 시작하고 web3에 자유롭게 접근할 수 있다
  startApp()

})

참고: 메타마스크 말고도 사용자들이 쓸 수 있는 다른 개인 키 관리 프로그램도 있다. 미스트(Mist) 웹 브라우저 같은 것들이지. 하지만, 그것들도 모두 web3 변수를 주입하는 동일한 형태를 사용한다. 그러니 사용자들이 다른 프로그램을 쓰더라도 여기서 설명하는 방식으로 사용자의 Web3 프로바이더를 인식해야 한다.

컨트랙트와 대화하기

이제 메타마스크의 Web3 프로바이더로 Web3.js를 초기화했으니, 우리의 스마트 컨트랙트와 통신을 할 수 있도록 만들자.

Web3.js는 스마트 컨트랙트와 통신을 위해 2가지를 필요로 한다.

1. 컨트랙트의 주소
2. ABI

컨트랙트 주소란?

스마트 컨트랙트를 모두 작성한 후, 컨트랙트를 컴파일한 후 이더리움에 배포한다.

컨트랙트를 배포한 후, 해당 컨트랙트는 영원히 존재하는, 이더리움 상에서 고정된 주소를 얻을 것이네. 레슨2를 상기해보면, 이더리움 메인넷에서 크립토키티의 주소는 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d였다.

스마트 컨트랙트와 통신을 하기 위해서는 컨트랙트 배포 후 이 주소를 복사해 사용해야 한다.

컨트랙트 ABI란?

컨트랙트 ABI의 정의

ABI는 Application Binary Interface의 줄임말이다. 기본적으로 JSON 형태로 컨트랙트의 메소드를 표현한다. 컨트랙트가 이해할 수 있도록 하려면 Web3.js가 어떤 형태로 함수 호출을 해야 하는지 알려주는 것이다.

ABI 얻는 방법?

이더리움에 배포하기 위해 컨트랙트를 컴파일할 때 솔리디티 컴파일러는ABI를 반환한다. 그러니 컨트랙트 주소와 함께 이를 복사하여 저장해놓고 사용하면 된다.

Web3.js 컨트랙트 인스턴스화하기

컨트랙트의 주소와 ABI를 얻고 나면, 다음과 같이 Web3에서 인스턴스화할 수 있다.

// myContract 인스턴스화
var myContract = new web3js.eth.Contract(myABI, myContractAddress);

컨트랙트 함수 호출하기

Web3.js는 컨트랙트의 함수를 호출하기 위해 우리가 사용할 두 개의 메소드를 가지고 있다. - call과 send

• 둘의 차이점은 call은 view와 pure함수에서만 사용 가능하고, send는 그 이외 함수에서 사용된다는 점이다.
• 따라서 call은 가스를 소모하지 않는다.

Call 정의

call은 view와 pure 함수에서 사용된다. 로컬 노드에서만 실행되고, 블록체인에 트랜잭션을 만들지 않는다.

📝 복습: view와 pure 함수는 읽기 전용이고 블록체인에서 상태를 변경한다. 가스를 전혀 소모하지 않고, 메타마스크에서 트랜잭션에 서명하라고 사용자에게 창을 띄우지도 않는다.

call 사용하기

Web3.js 를 사용하여, 다음과 같이 123을 매개 변수로 myMethod라는 이름의 함수를 call할 수 있다.

myContract.methods.myMethod(123).call()

Send 정의

send는 트랜잭션을 만들고 블록체인 상의 데이터를 변경한다. view와 pure가 아닌 모든 함수에 대해 send를 사용해야 한다.

참고: 트랜잭션을 send하는 것은 사용자에게 가스를 지불하도록 하고, 메타마스크에서 트랜잭션에 서명하라고 창을 띄울 것이다. Web3 프로바이더로 메타마스크를 사용할 때, send()를 호출하면 자동으로 이 모든 것이 이루어지고, 우리의 코드에 어떤 특별한 것도 추가할 필요가 없다. 꽤나 훌륭하지!?

send 사용하기

Web3.js를 사용하여, 다음과 같이 123을 매개 변수로 myMethod라는 이름의 함수를 호출하는 트랜잭션을 send할 수 있다.

myContract.methods.myMethod(123).send()

구문은 call()과 거의 똑같다.

call과 다른 send만의 특징

1. 트랜잭션을 전송(send)하려면 함수를 호출한 사람의 from 주소가 필요하다(솔리디티 코드에서는 msg.sender).

• 따라서, 메타마스크가 나타나 디앱 사용자들에게 서명을 하도록 한다.

2. 트랜잭션 전송(send)은 가스를 소모한다.

3. 사용자가 트랜잭션 전송을 하고 난 후 실제로 블록체인에 적용될 때까지는 상당한 지연이 발생한다.

• 트랜잭션이 블록에 포함될 때까지 기다려야 하는데, 이더리움의 평균 블록 시간은 15초이다.
• 만약 이더리움에 보류 중인 거래가 많거나 사용자가 가스 가격을 지나치게 낮게 보낼 경우, 우리 트랜잭션이 블록에 포함되길 기다려야 하고, 이는 몇 분씩 시간이 소요될 수 있다.

  데이터 받기

  컨트랙트 데이터 접근 - call함수 이용

좀비 배열을 public으로 만들었었다.

Zombie[] public zombies;

솔리디티에서, public으로 변수를 선언하면 자동으로 같은 이름의 퍼블릭 getter 함수를 만들어 낸다. 그러니 ID 15인 좀비를 찾길 원한다면, 변수를 함수인 것처럼 호출할 수 있다 : zombies(15).

프론트엔드에서 좀비 ID를 받아 해당 좀비에 대해 컨트랙트에 질의를 보내고, 결과를 반환하는 자바스크립트 함수를 작성하는 방법은 다음과 같다.

function getZombieDetails(id) {
  return cryptoZombies.methods.zombies(id).call()
}

// 함수를 호출하고 결과를 가지고 무언가를 처리:
getZombieDetails(15)
.then(function(result) {
  console.log("Zombie 15: " + JSON.stringify(result));
});

cryptoZombies.methods.zombies(id).call()는 Web3 프로바이더와 통신하여 컨트랙트의 Zombie[] public zombies에서 인덱스가 id인 좀비를 반환하도록 할 것이다.

• 이 과정은 외부 서버로 API 호출을 하는 것처럼 비동기적으로 일어난다. 즉 Web3는 여기서 Promise를 반환한다.

Promise가 만들어지면(이는 Web3 프로바이더로부터 응답을 받았다는 것을 의미하지) 우리 예제 코드는 then 문장을 실행하고, 여기서 result를 콘솔에 로그로 기록한다.

result는 다음과 같이 생긴 자바스크립트 객체이다.

{
  "name": "H4XF13LD MORRIS'S COOLER OLDER BROTHER",
  "dna": "1337133713371337",
  "level": "9999",
  "readyTime": "1522498671",
  "winCount": "999999999",
  "lossCount": "0" // Obviously.
}

메타마스크에서 사용자 계정 가져오기

메타마스크는 확장 프로그램 안에서 사용자들이 다수의 계정을 관리할 수 있도록 해준다.

우리는 주입되어 있는 web3 변수에 현재 활성화된 계정이 무엇인지 다음처럼 확인할 수 있다.

var userAccount = web3.eth.accounts[0]

• 사용자가 언제든지 메타마스크에서 활성화된 계정을 바꿀 수 있다.
• 따라서, 이 변수의 값이 바뀌었는지 확인하기 위해 계속 감시를 하고 값이 바뀌면 그에 따라 UI를 업데이트해야 한다.

이를 위해 다음과 같이 setInterval을 쓸 수 있다.

var accountInterval = setInterval(function() {
  // 계정이 바뀌었는지 확인
  if (web3.eth.accounts[0] !== userAccount) {
    userAccount = web3.eth.accounts[0];
    // 새 계정에 대한 UI로 업데이트하기 위한 함수 호출
    updateInterface();
  }
}, 100);

• 여기서는 userAccount가 여전히 web3.eth.accounts[0]과 같은지 확인하기 위해 100밀리초마다 확인한다.
• 그렇지 않다면, userAccount에 현재 활성화된 계정을 다시 할당하고, 화면을 업데이트하기 위한 함수를 호출한다.

좀비 데이터 보여주기 - 간단한 예제

jQuery 이용 정보 출력

// 우리 컨트랙트에서 좀비 상세 정보를 찾아, `zombie` 객체 반환
getZombieDetails(id)
.then(function(zombie) {
  // HTML에 변수를 넣기 위해 ES6의 "template literal" 사용
  // 각각을 #zombies div에 붙여넣기
  $("#zombies").append(`<div class="zombie">
    <ul>
      <li>Name: ${zombie.name}</li>
      <li>DNA: ${zombie.dna}</li>
      <li>Level: ${zombie.level}</li>
      <li>Wins: ${zombie.winCount}</li>
      <li>Losses: ${zombie.lossCount}</li>
      <li>Ready Time: ${zombie.readyTime}</li>
    </ul>
  </div>`);
});

메타마스크 이용해 web.js에서 함수 호출하기

사용자가 호출할 함수 컨트랙트 createRandomZombie.

여기서 우리 컨트랙트의 솔리디티 코드는 아래와 같다.

function createRandomZombie(string _name) public {
  require(ownerZombieCount[msg.sender] == 0);
  uint randDna = _generateRandomDna(_name);
  randDna = randDna - randDna % 100;
  _createZombie(_name, randDna);
}

아래 코드는 메타마스크를 사용해 Web3.js에서 위 함수를 호출하는 방법이다.

function createRandomZombie(name) {
  // 시간이 꽤 걸릴 수 있으니, 트랜잭션이 보내졌다는 것을
  // 유저가 알 수 있도록 UI를 업데이트해야 함
  $("#txStatus").text("Creating new zombie on the blockchain. This may take a while...");
  // 우리 컨트랙트에 전송하기:
  return CryptoZombies.methods.createRandomZombie(name)
  .send({ from: userAccount })
  .on("receipt", function(receipt) {
    $("#txStatus").text("Successfully created " + name + "!");
    // 블록체인에 트랜잭션이 반영되었으며, UI를 다시 그려야 함
    getZombiesByOwner(userAccount).then(displayZombies);
  })
  .on("error", function(error) {
    // 사용자들에게 트랜잭션이 실패했음을 알려주기 위한 처리
    $("#txStatus").text(error);
  });
}

• 위 함수는 Web3 프로바이더에게 트랜잭션을 전송(send)하고, 몇 가지 이벤트 리스너들을 연결한다.

• receipt : 트랜잭션이 이더리움의 블록에 포함될 때, 즉 좀비가 생성되고 우리의 컨트랙트에 저장되었을 때 발생한다.

• error : 트랜잭션이 블럭에 포함되지 못했을 때, 예를 들어 사용자가 충분한 가스를 전송하지 않았을 때 발생하게 된다. 이 경우 프론트엔드의 UI를 통해 사용자에게 트랜잭션이 전송되지 않았음을 알리고, 다시 시도할 수 있도록 해야 한다.

  참고: send를 호출할 때 gas와 gasPrice를 선택적으로 지정할 수 있다. .send({ from: userAccount, gas: 3000000 })와 같이 작성한다. 만약 지정하지 않는다면, 메타마스크는 사용자가 이 값들을 선택할 수 있도록 한다.

Payable 처리

payable함수는 web3.js에서 특별한 처리가 필요하다.

payable함수 추가 방법

ZombieHelper를 다시 생각해보면, 우린 사용자가 레벨업할 수 있는 곳에 payable 함수를 추가했었다.

function levelUp(uint _zombieId) external payable {
  require(msg.value == levelUpFee);
  zombies[_zombieId].level++;
}

함수를 이용해 이더를 보내는 방법은 간단하지만, 이더가 아니라 wei로 얼마를 보낼지 정하는 것에는 제한이 있다.

Wei란?

wei는 이더의 가장 작은 하위 단위이다.

• 하나의 이더는 10^18개의 wei이다.
• Web3.js에는 이러한 작업을 해주는 변환 유틸리티가 있다.

// 이렇게 하면 1 ETH를 Wei로 바꿀 것이네
web3js.utils.toWei("1");

• 괄호 안에 있는 금액을 wei로 보낸다는 의미!

DApp에서, levelUpFee = 0.001 ether로 설정했었다. 그러니 levelup 함수를 호출할 때, 아래의 코드를 써서 사용자가 0.001 이더를 보내게 할 수 있다.

CryptoZombies.methods.levelUp(zombieId)
.send({ from: userAccount, value: web3js.utils.toWei("0.001") })

이벤트 구독하기

새로운 업데이트 구독하기

zombiefactory.sol을 다시 생각해보면, 새로운 좀비가 생성될 때마다 매번 호출되던 NewZombie라는 이벤트가 있었다.

event NewZombie(uint zombieId, string name, uint dna);

Web3.js에서 이벤트를 구독하여 해당 이벤트가 발생할 때마다 Web3 프로바이더가 코드 내의 어떠한 로직을 실행시키도록 할 수 있다.

cryptoZombies.events.NewZombie()
.on("data", function(event) {
  let zombie = event.returnValues;
  // `event.returnValue` 객체에서 이 이벤트의 세 가지 반환 값에 접근할 수 있다.
  console.log("새로운 좀비가 태어났습니다!", zombie.zombieId, zombie.name, zombie.dna);
}).on("error", console.error);

• 이 코드는 현재 사용자의 좀비만이 아니라 DApp에서 생성된 모든 좀비에 대한 알람을 보낸다.

indexed 사용하기 - 선택적 이벤트 수신

이벤트를 필터링하고 현재 사용자와 연관된 변경만을 수신하기 위해서 ERC721을 구현할 때 Transfer 이벤트에서 했던 것처럼 컨트랙트에 indexed 키워드를 사용해야 한다.

event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);

• 경우, _from과 _to가 indexed 되어 있기 때문에, 우리 프론트엔드의 이벤트 리스너에서 이들을 필터링할 수 있다.

// `filter`를 사용해 `_to`가 `userAccount`와 같을 때만 코드를 실행
cryptoZombies.events.Transfer({ filter: { _to: userAccount } })
.on("data", function(event) {
  let data = event.returnValues;
  // 현재 사용자가 방금 좀비를 받았네!
  // 해당 좀비를 보여줄 수 있도록 UI를 업데이트할 수 있도록 여기에 추가
}).on("error", console.error);

• event와 indexed 영역을 사용하는 것은 컨트랙트에서 변화를 감지하고 프론트엔드에 반영할 수 있게 하는 유용한 방법이다.

지난 이벤트에 대해 질의하기

getPastEvents를 이용해 지난 이벤트들에 대해 질의를 하고, fromBlock과 toBlock 필터들을 이용해 이벤트 로그에 대한 시간 범위를 솔리디티에 전달할 수 있다. (여기서 block은 이더리움 블록 번호를 나타낸다)

cryptoZombies.getPastEvents("NewZombie", { fromBlock: 0, toBlock: "latest" })
.then(function(events) {
  // `events`는 우리가 위에서 했던 것처럼 반복 접근할 `event` 객체들의 배열이네.
  // 이 코드는 생성된 모든 좀비의 목록을 우리가 받을 수 있게 할 것이네.
});

• 위 메소드를 사용해서 시작 시간부터의 이벤트 로그들에 대해 질의를 할 수 있기 때문에, 이벤트를 저렴한 형태의 storage로 사용할 수 있다.

  이벤트를 저렴한 형태의 storage로 사용하기

• 데이터를 블록체인에 기록하는 것은 솔리디티에서 가장 비싼 비용을 지불하는 작업 중 하나였다 하지만 이벤트를 이용하는 것은 가스 측면에서 훨씬 더 저렴하다.

• 단점이 되는 부분은 스마트 컨트랙트 자체 안에서는 이벤트를 읽을 수 없다는 것이다. 하지만 히스토리로 블록체인에 기록하여 앱의 프론트엔드에서 읽기를 원하는 데이터가 있다면, 이벤트 히스토리를 유용하게 사용할 수 있다.

이더리움 상의 토큰

토큰이란?

• 이더리움에서 토큰은 기본적으로 몇몇 공통 규약을 따르는 스마트 컨트랙트이다.컨트랙트 안에서 누가 얼마나 많은 토큰을 가지고 있는지 기록하고, 몇몇 함수를 가지고 사용자들이 그들의 토큰을 다른 주소로 전송할 수 있게 한다.
• 즉, 다른 모든 토큰 컨트랙트가 사용하는 표준 함수 집합을 구현한게 토큰예를 들면 transfer(address _to, uint256 _value)나 balanceOf(address _owner) 같은 함수!

내부적으로 스마트 컨트랙트는 보통 mapping(address => uint256) balances와 같은 매핑을 가지고 있다. 각각의 주소에 잔액이 얼마나 있는지 기록하는 것. 토큰도 스마트 컨트랙트의 일종이므로 저 매핑을 가지고 있다.

즉 기본적으로 토큰은 그냥 하나의 컨트랙트!

ERC20 토큰 상호작용

💵 ERC20 토큰은 화폐처럼 사용되는 토큰으로 적절하다.

모든 ERC20 토큰들이 똑같은 이름의 동일한 함수 집합을 공유하기 때문에, 이 토큰들에 똑같은 방식으로 상호작용이 가능하다.

• 즉 하나의 ERC20 토큰과 상호작용할 수 있는 애플리케이션 하나를 만들면, 이 앱이 다른 어떤 ERC20 토큰과도 상호작용이 가능하다.
• 한 거래소에서 새로운 ERC20 토큰을 상장할 때, 실제로는 이 거래소에서 통신이 가능한 또 하나의 스마트 컨트랙트를 추가하는 것이다.
• 사용자들은 이 컨트랙트에 거래소의 지갑 주소에 토큰을 보내라고 할 수 있고, 거래소에서는 이 컨트랙트에 사용자들이 출금을 신청하면 토큰을 다시 돌려보내라고 할 수 있게 만드는 것!

따라서, 로직은 한번 구현하고, 새로운 토큰을 추가하는 것은 DB에 새 컨트랙트 주소를 추가하기만 하면 된다. (토큰이 스마트 컨트랙트 그 자체이므로)

다른 토큰 표준

다른 종류의 토큰이 필요한 이유

지금 만들고 있는 좀비 게임에서는 아래와 같은 이유로 ERC20을 못쓴다..!

1. 좀비는 화폐처럼 분할할 수가 없다.

• 다른 사람에게 0.237ETH를 보낼 수 있지만, 0.237개의 좀비를 보내는 것은 불가능하다.

1. 모든 좀비가 똑같지 않다.

• 다른 사람의 레벨2 좀비 Steve는 내 레벨732 좀비 H4XF13LD MORRIS 💯💯😎💯💯와는 완전히 다르다.

ERC721 토큰

☄️ 크립토좀비와 같은 크립토 수집품을 위해 더 적절한 토큰 표준은 ERC721 토큰!

ERC712 토큰을 사용하는 이유

1. ERC721 토큰은 교체가 불가하다.

• 각각의 토큰이 유일하고 분할이 불가하다.
• 각 토큰을 하나의 전체 단위로만 거래할 수 있다.
• 각각의 토큰은 유일한 ID를 가지고 있다.

1. 경매나 중계 로직을 직접 구현하지 않아도 된다.

• ERC721과 같은 표준을 사용하면 컨트랙트에서 사용자들이 우리의 좀비를 거래/판매할 수 있도록 하는 로직이 이미 구현되어 있다.

ERC721 표준, 다중 상속

ERC721 표준

contract ERC721 {
  event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
  event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);

  function balanceOf(address _owner) public view returns (uint256 _balance);
  function ownerOf(uint256 _tokenId) public view returns (address _owner);
  function transfer(address _to, uint256 _tokenId) public;
  function approve(address _to, uint256 _tokenId) public;
  function takeOwnership(uint256 _tokenId) public;
}

• 위의 메소드를 다 구현해서 표준을 맞춰야 ERC721 토큰을 사용할 수 있다.

다중 상속

contract SatoshiNakamoto is NickSzabo, HalFinney {
  // , 로 간단히 다중 상속 가능
}

• 다중 상속은 그냥 , 로 구분해서 나란히 쓴다.

ERC721 구현

메소드 구현

balanceOf

  function balanceOf(address _owner) public view returns (uint256 _balance);

• 이 함수는 단순히 address를 받아, 해당 address가 토큰을 얼마나 가지고 있는지 반환한다.
• 현재 만들고 있는 게임의 경우, 토큰은 좀비들이 된다.

ownerOf

  function ownerOf(uint256 _tokenId) public view returns (address _owner);

• 이 함수에서는 토큰 ID를 받아, 이를 소유하고 있는 사람의 address를 반환한다.

전송 로직

첫번째 방법 - transter

function transfer(address _to, uint256 _tokenId) public;

• 토큰을 보내는 사람이 함수 호출
• 토큰의 소유자가 전송 상대의 address, 전송하고자 하는 _tokenId와 함께 transfer 함수를 호출하는 것이다.

두번째 방법 - approve

function approve(address _to, uint256 _tokenId) public;
function takeOwnership(uint256 _tokenId) public;

• 토큰을 받는 사람이 함수 호출
• 토큰의 소유자가 먼저 위에서 본 정보들을 가지고 approve를 호출하는 형식이다.
• 그 후, 컨트랙트에 누가 해당 토큰을 가질 수 있도록 허가를 받았는지 저장한다.
• 보통 mapping (uint256 => address)를 써서 이를 확인한다.
• 누군가 takeOwnership을 호출하면, 해당 컨트랙트는 이 msg.sender가 소유자로부터 토큰을 받을 수 있게 허가를 받았는지 확인한다. 그리고 허가를 받았다면 해당 토큰을 그에게 전송한다.

transfer와 takeOwnership 모두 동일한 전송 로직을 가지고 있다. 순서만 반대인 것!(전자는 토큰을 보내는 사람이 함수를 호출, 후자는 토큰을 받는 사람이 호출).

그러니 이 로직만의 프라이빗 함수, _transfer를 만들어 추상화하면 두 함수에서 모두에서 효율적으로 사용할 수 있다.

  function _transfer(address _from, address _to, uint256 _tokenId) private {
      ownerZombieCount[_to]++;
      ownerZombieCount[_from]--;
      zombieToOwner[_tokenId] = _to;
      Transfer(_from, _to, _tokenId);
  }

approve 구현

작동 방식 요약

1. 소유자인 자네가 새로운 소유자의 address와 그에게 보내고 싶은 _tokenId를 사용하여 approve를 호출한다.
2. 새로운 소유자가 _tokenId를 사용하여 takeOwnership 함수를 호출하면, 컨트랙트는 그가 승인된 자인지 확인하고 그에게 토큰을 전송한다.

• 함수 호출 사이에 누가 무엇에 대해 승인이 되었는지 저장할 데이터 구조가 필요하다.

컨트랙트 보안

🌝 컨트랙트 보안 고려 요소: 오버플로우, 언더플로우

오버플로우

오버플로우란 무엇인가?

우리가 8비트 데이터를 저장할 수 있는 uint8 하나를 가지고 있다고 해보지. 이 말인즉 우리가 저장할 수 있는 가장 큰 수는 이진수로 11111111(또는 십진수로 2^8 - 1 = 255)가 된다.

uint8 number = 255;
number++;

이 예시에서, 우리는 이 변수에 오버플로우를 만들었다.

• 위에서 number는 직관과는 다르게 0이 된다.이진수 11111111에 1을 더하면, 이 수는 00000000으로 돌아간다.

언더플로우

언더플로우란?

언더플로우는 오버플로우와 유사하게 0 값을 가진 uint8에서 1을 빼면, 255와 같아지는 것을 말한다. (uint에 부호가 없어, 음수가 될 수 없기 때문에!)

따라서, 미래에 우리의 DApp에 예상치 못한 문제가 발생하지 않도록 컨트랙트에 보호 장치를 두어야 한다! (컨트랙트 한번 올리면 수정도 못함..)

SafeMath 사용하기

SafeMath란?

오버플로우와 언더플로우를 막기 위해, OpenZeppelin에서 기본적으로 이런 문제를 막아주는 SafeMath라고 하는 라이브러리를 만들었다.

솔리디티에서 라이브러리란?

라이브러리(Library)는 솔리디티에서 특별한 종류의 컨트랙트이다. 이게 유용하게 사용되는 경우 중 하나는 기본(native) 데이터 타입에 함수를 붙일 때!

예를 들어, SafeMath 라이브러리를 쓸 때는 using SafeMath for uint256이라는 구문을 사용한다. SafeMath 라이브러리는 4개의 함수를 가지고 있다. - add, sub, mul,div . 함수 접근은 아래와 같이 이루어진다.

using SafeMath for uint256;

uint256 a = 5;
uint256 b = a.add(3); // 5 + 3 = 8
uint256 c = a.mul(2); // 5 * 2 = 10

SafeMath 내부의 코드

safemath 라이브러리 코드

library SafeMath {

  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}

라이브러리는 using 키워드를 사용할 수 있게 해준다. 이를 통해 라이브러리의 메소드들을 다른 데이터 타입에 적용할 수 있다.

safemath 적용 예시

using SafeMath for uint;
// 우리는 이제 이 메소드들을 아무 uint에서나 쓸 수 있다.
uint test = 2;
test = test.mul(3); // test는 이제 6이 된다
test = test.add(5); // test는 이제 11이 된다

• mul과 add 함수는 각각 2개의 인수를 필요로 한다.하지만 우리가 using SafeMath for uint를 선언할 때, 우리가 함수를 적용하는 uint(test)는 첫 번째 인수로 자동으로 전달된다.

safemath 작동 방식 - add함수

function add(uint256 a, uint256 b) internal pure returns (uint256) {
  uint256 c = a + b;
  //여기가 오버플로우를 막는 부분
  assert(c >= a);
  return c;
}

• 기본적으로 add는 그저 2개의 uint를 +처럼 더한다.
• 하지만 그 안에 assert 구문을 써서 그 합이 a보다 크도록 보장하고, 이것이 오버플로우를 막아준다.

assert의 역할

• assert는 조건을 만족하지 않으면 에러를 발생시킨다는 점에서 require와 비슷하다.
• assert와 require의 차이점은, require는 함수 실행이 실패하면 남은 가스를 사용자에게 되돌려 주지만, assert는 그렇지 않다는 것이다.
• 따라서, 대부분 코드에 require를 쓰고, assert는 일반적으로 코드가 심각하게 잘못 실행될 때 사용한다.

코드에 SafeMath 사용하기

오버플로우나 언더플로우를 막기 위해, 우리의 코드에서 +, -, * 또는 /을 쓰는 곳을 찾아 add, sub, mul, div로 교체한다.

예를 들어, 아래처럼 하는 대신

myUint++;

이렇게 사용해 오버플로우와 언더플로우를 방지한다.

myUint = myUint.add(1);

솔리디티 주석 - natspec

/// @title 기본적인 산수를 위한 컨트랙트
/// @author H4XF13LD MORRIS 💯💯😎💯💯
/// @notice 지금은 곱하기 함수만 추가한다.
contract Math {
  /// @notice 2개의 숫자를 곱한다.
  /// @param x 첫 번쨰 uint.
  /// @param y 두 번째 uint.
  /// @return z (x * y) 곱의 값
  /// @dev 이 함수는 현재 오버플로우를 확인하지 않는다.
  function multiply(uint x, uint y) returns (uint z) {
    // 이것은 일반적인 주석으로, natspec에 포함되지 않는다.
    z = x * y;
  }
}

• @title과 @author : 말 그대로 제목, 쓴사람
• @notice : 사용자에게 컨트랙트/함수가 무엇을 하는지 설명한다.
• @dev : 개발자에게 추가적인 상세 정보를 설명한다.
• @param과 @return : 함수에서 어떤 매개 변수와 반환값을 가지는지 설명한다.
• 모든 태그가 필수는 아니지만, @dev는 대부분 남겨야 함!

함수 제어자

접근 제어자

• private : 컨트랙트 내부의 다른 함수들에서만 호출될 수 있음
• internal : private과 비슷하지만, 해당 컨트랙트를 상속하는 컨트랙트에서도 호출될 수 있음
• external : 오직 컨트랙트 외부에서만 호출
• public : 내외부 모두에서, 어디서든 호출

상태 제어자

• view : 해당 함수를 실행해도 어떤 데이터도 저장/변경되지 않음
• pure : 해당 함수가 어떤 데이터도 블록체인에 저장하지 않을 뿐만 아니라, 블록체인으로부터 어떤 데이터도 읽지 않음

둘 다 컨트랙트 외부에서 호출됐을 경우, 가스를 전혀 소모하지 않고 다른 함수에 의해 내부 호출되었을 경우에는 가스를 소모한다.

사용자 정의 제어자

• onlyOwner와 aboveLevel 같은 것!
• 함수에 이 제어자들이 어떻게 영향을 줄지를 결정하는 로직을 구성할 수 있네.

이런 제어자들은 함수 하나에 다음처럼 함께 사용할 수 있다.

function test() external view onlyOwner anotherModifier { /* ... */ }

payable 제어자 (함수 제어자)

✨ payable은 이더를 받을 수 있는 특별한 함수 유형!

• payable은 이더를 받을 수 있는 특별한 함수 유형이다.
• 이더리움에서는 돈, 데이터, 컨트랙트 코드 자체가 모두 이더리움 위에 존재하기 때문에 함수를 실행하는 동시에 컨트랙트에 돈을 지불하는 것이 가능하다.

이를 통해 함수를 실행하기 위해 컨트랙트에 일정 금액을 지불하게 하는 것 같은 구조를 아래와 같이 만들어낼 수 있다.

contract OnlineStore {
  function buySomething() external payable {
    // 함수 실행에 0.001이더가 보내졌는지 확실히 하기 위해 확인
    require(msg.value == 0.001 ether);
    // 보내졌다면, 함수를 호출한 자에게 디지털 아이템을 전달하기 위한 내용 구성
    transferThing(msg.sender);
  }
}

여기서, msg.value는 컨트랙트로 이더가 얼마나 보내졌는지 확인하는 방법이고, ether는 기본적으로 포함된 단위이다.

여기서 일어나는 일은 누군가 web3.js(DApp의 자바스크립트 프론트엔드)에서 다음과 같이 함수를 실행할 때 발생한다.

// `OnlineStore`는 이더리움 상의 컨트랙트를 가리킨다고 가정한다.
OnlineStore.buySomething({from: web3.eth.defaultAccount, value: web3.utils.toWei(0.001)})

value 필드를 보면, 자바스크립트 함수 호출에서 이 필드를 통해 ether를 얼마나 보낼지 결정한다.

참고: 만약 함수가 payable로 표시되지 않았는데 위에서 본 것처럼 이더를 보내려 한다면, 함수에서 트랜잭션을 거부할 것이다.

💸 트랜젝션

컨트랙트로 이더를 보내면, 해당 컨트랙트의 이더리움 계좌에 이더가 저장되고 거기에 갇히게 된다. 따라서 컨트랙트로부터 이더를 인출하는 함수를 만들어야 한다.

다음과 같이 컨트랙트에서 이더를 인출하는 함수를 작성할 수 있다.

contract GetPaid is Ownable {
  function withdraw() external onlyOwner {
    owner.transfer(this.balance);
  }
}

💡 Ownable 컨트랙트를 import 했다고 가정하고 owner와 onlyOwner를 사용하고 있다는 것을 참고!

transfer 함수 사용

1. transfer 함수를 사용해서 이더를 특정 주소로 전달할 수 있다.

• 그리고 this.balance는 컨트랙트에 저장돼있는 전체 잔액을 반환한다. 에를 들어, 100명의 사용자가 나의 컨트랙트에 1이더를 지불했다면, this.balance는 100이더가 될 것이다.

2. transfer 함수를 써서 특정한 이더리움 주소에 돈을 보낼 수 있다.

• 예를 들어, 만약 누군가 한 아이템에 대해 초과 지불을 했다면, 이더를 msg.sender로 되돌려주는 함수를 만들 수도 있다.

  uint itemFee = 0.001 ether;
  msg.sender.transfer(msg.value - itemFee);

• 또는 구매자와 판매자가 존재하는 컨트랙트에서, 판매자의 주소를 storage에 저장하고, 누군가 판매자의 아이템을 구매하면 구매자로부터 받은 요금을 그에게 전달할 수도 있다. seller.transfer(msg.value)

이런 식으로 누구에게도 제어되지 않는 분산 장터를 만들 수 있다!

🪅 이더리움에서 난수 생성하기

😂 솔리디티에서는 난수를 안전하게 생성할 수 없다.....!

keccak256을 통한 난수 생성(못씀..)

keccak256을 이용한 난수 생성 방법

• 솔리디티에서 난수를 만들기에 가장 좋은 방법은 keccak256 해시 함수를 쓰는 것이다.

다음과 같은 방식으로 난수를 만들어낼 수 있다

// Generate a random number between 1 and 100:
uint randNonce = 0;
uint random = uint(keccak256(now, msg.sender, randNonce)) % 100;
randNonce++;
uint random2 = uint(keccak256(now, msg.sender, randNonce)) % 100;

이 예시에서는 now의 타임스탬프 값, msg.sender, 증가하는 nonce(딱 한 번만 사용되는 숫자, 즉 똑같은 입력으로 두 번 이상 동일한 해시 함수를 실행할 수 없게 함)를 받고 있다.

그리고서 keccak을 사용하여 이 입력들을 임의의 해시 값으로 변환하고, 변환한 해시 값을 uint로 바꾼 후, % 100을 써서 마지막 2자리 숫자만 받도록 했네. 이를 통해 0과 99 사이의 완전한 난수를 얻을 수 있다.

keccak을 이용한 난수를 못쓰는 이유

이 메소드는 정직하지 않은 노드의 공격에 취약하다.

이더리움 검증 과정

1. 이더리움에서는 컨트랙트의 함수를 실행하면 transaction으로서 네트워크의 노드 하나 혹은 여러 노드에 실행을 알리게 된다.

2. 그 후 네트워크의 노드들은 여러 개의 트랜잭션을 모으고, 작업 증명으로 알려진 계산이 매우 복잡한 수학적 문제를 먼저 풀기 위한 시도를 하게 된다.

3. 그리고 해당 트랜잭션 그룹을 그들의 작업 증명(PoW)과 함께 _블록_으로 네트워크에 배포하게 된다.

4. 한 노드가 어떤 PoW를 풀면, 다른 노드들은 그 PoW를 풀려는 시도를 멈추고 해당 노드가 보낸 트랜잭션 목록이 유효한 것인지 검증한다.

5. 유효하다면 해당 블록을 받아들이고 다음 블록을 풀기 시작한다.

이것이 우리의 난수 함수를 취약하게 만든다.

트랜잭션 조작 가능

1. 동전 던지기 컨트랙트를 사용한다고 가정 - 앞면이 나오면 돈이 두 배가 되고, 뒷면이 나오면 모두 다 잃는 것이다. 앞뒷면을 결정할 때 위에서 본 난수 함수를 사용한다고 가정한다. (random >= 50은 앞면, random < 50은 뒷면이네).

2. 내가 만약 노드를 실행하고 있다면, 나는 오직 나의 노드에만 트랜잭션을 알리고 이것을 공유하지 않을 수 있다. (하나 또는 여러 노드에 실행을 알리면 되니까)

3. 그 후 내가 이기는지 확인하기 위해 동전 던지기 함수를 실행할 수 있다.

• 그리고 만약 내가 진다면, 내가 풀고 있는 다음 블록에 해당 트랜잭션을 포함하지 않는 것을 선택한다.
• 난 이것을 내가 결국 동전 던지기에서 이기고 다음 블록을 풀 때까지 무한대로 반복할 수 있고, 이득을 볼 수 있다.

그럼 이더리움에서는 어떻게 난수를 안전하게 만들어낼 수 있을까?

블록체인의 전체 내용은 모든 참여자에게 공개되므로, 이건 풀기 어려운 문제이고 그 해결 방법은 여러가지가 있다.StackOverflow

• 하나의 방법은 이더리움 블록체인 외부의 난수 함수에 접근할 수 있도록 오라클을 사용하는 것이다. (내부에서 만들지 말고 외부 난수 함수를 가져온다!)

• oracle: 이더리움 외부에서 데이터를 받아오는 안전한 방법 중 하나

• 오라클을 사용해서 블록체인 밖에서 안전한 난수를 만들어 온체인에서 사용

솔리디티 특징

컨트랙트의 불변성

이더리움에 컨트랙트를 배포하고 나면, 컨트랙트는 변하지 않는다(Immutable). 다시 말하자면 컨트랙트를 수정하거나 업데이트할 수 없다는 것!

• 코드를 이후에 고칠 수 있는 방법이 없기 때문에 보안이 굉장히 큰 이슈가 됨
• 함수를 호출할 때마다, 코드에 쓰여진 그대로 함수가 실행될 것이라고 확신할 수 있다. 그 누구도 배포 이후에 함수를 수정하거나 예상치 못한 결과를 발생시키지 못한다.

외부 의존성

블록체인 외부에서 끌어온 데이터에 문제가 생겼을 경우, 나의 DApp이 작동하지 못할 수 있다. 따라서 외부에서 끌어오는 데이터는 가변 데이터로 저장한다.

//인터페이스 변수 선언만 한다.
KittyInterface kittyContract;

//함수 내부에서 address대입!
  function setKittyContractAddress(address _address) external {
    kittyContract = KittyInterface(_address);
  }

소유 가능한 콘트랙트

Ownable contract

위의 코드에서 함수를 external로 선언했기 때문에, 누구든 이 함수를 호출해 주소를 변경할 수 있다. 따라서 컨트랙트를 소유 가능하게 만들어 특별한 권리를 가진 소유자만 주소 변경이 가능하도록 설정한다.

아래에 나와있는 것은 OpenZeppelin 솔리디티 라이브러리에서 가져온 Ownable 컨트랙트이다. OpenZeppelin은 DApp에서 사용할 수 있는, 안전하고 커뮤니티에서 검증받은 스마트 컨트랙트의 라이브러리이다.

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;
  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() public {
    owner = msg.sender;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }
}

해당 코드 내부 요소 설명

• 생성자(Constructor): function Ownable()는 생성자이다. 자바에서처럼 컨트랙트와 동일한 이름을 가진, 생략할 수 있는 특별한 함수. 이 함수는 컨트랙트가 생성될 때 딱 한 번만 실행된다.
• 함수 제어자(Function Modifier): modifier onlyOwner(). 제어자는 다른 함수들에 대한 접근을 제어하기 위해 사용되는 일종의 유사 함수이다. 보통 함수 실행 전의 요구사항 충족 여부를 확인하는 데에 사용한다. onlyOwner의 경우에는 접근을 제한해서 오직 컨트랙트의 소유자만 해당 함수를 실행할 수 있도록 하기 위해 사용될 수 있다.

Ownable 컨트랙트의 기본 역할

1. 컨트랙트가 생성되면 컨트랙트의 생성자가 owner에 msg.sender(컨트랙트를 배포한 사람)를 대입한다.

2. 특정한 함수들에 대해서 오직 소유자만 접근할 수 있도록 제한 가능한 onlyOwner 제어자를 추가한다.

3. 새로운 소유자에게 해당 컨트랙트의 소유권을 옮길 수 있도록 한다.

대부분의 솔리디티 DApp들은 Ownable 컨트랙트를 복사/붙여넣기 하면서 시작한다.

함수 제어자

제어자란?

함수 제어자는 함수처럼 보이지만, function 키워드 대신 modifier 키워드를 사용한다. 그리고 함수를 호출하듯이 직접 호출할 수는 없다. 대신에 함수 정의부 끝에 해당 함수의 작동 방식을 바꾸도록 제어자의 이름을 붙일 수 있다.

onlyOwner를 살펴보면서 더 자세히 알아보도록 하자.

/**
 * @dev Throws if called by any account other than the owner.
 */
modifier onlyOwner() {
  require(msg.sender == owner);
  //원래 함수로 되돌아가는 코드는 아래쪽!
  _;
}

우리는 이 제어자를 다음과 같이 사용할 것이다.

contract MyContract is Ownable {
  event LaughManiacally(string laughter);

  // 아래 `onlyOwner`의 사용 방법을 잘 보자.
  function likeABoss() external onlyOwner {
    LaughManiacally("Muahahahaha");
  }
}

likeABoss 함수의 onlyOwner 제어자 부분을 보자. likeABoss 함수를 호출하면, onlyOwner의 코드가 먼저 실행된다. 그리고 onlyOwner의 _; 부분은 likeABoss 함수로 되돌아가 해당 코드를 실행하게 한다.

제어자 사용하기

제어자를 사용할 수 있는 다양한 방법이 있지만, 가장 일반적으로 쓰는 예시 중 하나는 함수 실행 전에 require 체크를 넣는 것이다.

onlyOwner의 경우에는, 함수에 이 제어자를 추가하면 오직 컨트랙트의 소유자만이 해당 함수를 호출할 수 있다.

🔎 참고: 이렇게 소유자가 컨트랙트에 특별한 권한을 갖도록 하는 것은 자주 필요하지만, 이게 악용될 수도 있다. 예를 들어, 소유자가 다른 사람의 좀비를 뺏어올 수 있도록 하는 백도어 함수를 추가할 수도 있음!

개발 시 주의사항

• 이더리움에서 돌아가는 DApp이라고 해서 그것만으로 분산화되어 있다고 할 수는 없다.
• 소유자에 의한 특별한 제어가 불가능한 상태인지 확인이 반드시 필요하다.
• 잠재적인 버그를 수정하고 DApp을 안정적으로 유지하도록 하는 것과 사용자들이 그들의 데이터를 믿고 저장할 수 있는 소유자가 없는 플랫폼을 만드는 것 사이에서 균형을 잘 잡는 것이 중요하다.

  인수를 가지는 함수 제어자

  함수 제어자는 인수를 가질 수 있음!

  // 사용자의 나이를 저장하기 위한 매핑
  mapping (uint => uint) public age;
  

// 사용자가 특정 나이 이상인지 확인하는 제어자 modifier olderThan(uint _age, uint _userId) { require (age[_userId] >= _age); _; }

// 차를 운전하기 위햐서는 16살 이상이어야 하네(적어도 미국에서는). // olderThan 제어자를 인수와 함께 호출하려면 이렇게 하면 된다. function driveCar(uint _userId) public olderThan(16, _userId) { // 필요한 함수 내용들 }

여기서 `olderthan` 제어자가 함수와 비슷하게 인수를 받는 것을 볼 수 있다. 그리고 `driveCar` 함수는 받은 인수를 제어자로 전달하고 있다.


## Gas
### 가스란? - 이더리움 DApp이 사용하는 연료
>솔리디티에서는 사용자들이 DApp의 함수를 실행할 때마다 _가스_라고 불리는 화폐를 지불해야 한다. 사용자는 이더(ETH, 이더리움의 화폐)를 이용해서 가스를 사기 때문에, DApp 함수를 실행하려면 사용자들은 ETH를 소모해야만 한다.

함수를 실행하는 데에 얼마나 많은 가스가 필요한지는 그 `함수의 로직`(논리 구조)이 얼마나 복잡한지에 따라 달라진다. 각각의 연산은 소모되는 가스 비용(gas cost)이 있고, 그 연산을 수행하는 데에 소모되는 `컴퓨팅 자원`의 양이 이 비용을 결정한다. 예를 들어, `storage`에 값을 쓰는 것은 두 개의 정수를 더하는 것보다 훨씬 비용이 높다. 함수의 `전체 가스 비용`은 그 함수를 구성하는 `개별 연산`들의 가스 비용을 모두 합친 것과 같다.

함수를 실행하는 것은 사용자들에게 실제 돈을 쓰게 하기 때문에, 이더리움에서 `코드 최적화`는 다른 프로그래밍 언어들에 비해 훨씬 더 중요하다. 만약 코드가 엉망이라면, 사용자들은 함수를 실행하기 위해 일종의 할증료를 더 내야 한다. 그리고 수천 명의 사용자가 이런 불필요한 비용을 낸다면 할증료가 수십 억 원까지 쌓일 수 있다.

### 가스는 왜 필요한가?
이더리움은 크고 느린, 하지만 굉장히 안전한 컴퓨터와 같다. 어떤 함수를 실행할 때, 네트워크상의 모든 개별 노드가 함수의 출력값을 `검증`하기 위해 그 함수를 실행해야 한다. 모든 함수의 실행을 검증하는 수천 개의 노드가 바로 이더리움을 `분산화`하고, 데이터를 보존하며 누군가 `검열`할 수 없도록 하는 요소가 된다.

이더리움을 만든 사람들은 누군가가 무한 반복문을 써서 네트워크를 방해하거나, 자원 소모가 큰 연산을 써서 네트워크 자원을 모두 사용하지 못하도록 만들길 원했다. 그래서 그들은 `연산 처리`에 `비용`이 들도록 만들었고, 사용자들은 `저장 공간` 뿐만 아니라 연산 `사용 시간`에 따라서도 비용을 지불해야 한다.

>참고: 사이드체인에서는 반드시 이렇지는 않다. 크립토좀비를 만든 사람들이 Loom Network에서 만들고 있는 것들이 좋은 예시. 이더리움 메인넷에서 월드 오브 워크래프트 같은 게임을 직접적으로 돌리는 것은 절대 말이 되지 않는다. 가스 비용이 엄청나게 높을 것이기 때문이다. 하지만 다른 합의 알고리즘을 가진 사이드체인에서는 가능할 수 있다. 

### 가스를 아끼기 위한 구조체 압축
앞에서 우리는 `uint`에 다른 타입들이 있다는 것을 배웠다. `uint8`, `uint16`, `uint32`, 기타 등등..

기본적으로는 이런 하위 타입들을 쓰는 것은 아무런 이득이 없다. 왜냐하면 솔리디티에서는 `uint`의 크기에 상관없이 `256비트`의 `저장 공간`을 미리 잡아놓기 때문이지. 예를 들자면, `uint(uint256)`대신에 `uint8`을 쓰는 것은 가스 소모를 줄이는 데에 아무 영향이 없다.

하지만 여기에 예외가 하나 있다. 바로 `struct`의 안에서!!

만약 구조체 안에 여러 개의 `uint`를 만든다면, 가능한 더 작은 크기의 `uint`를 쓰도록 해야 한다. 솔리디티에서 그 변수들을 더 적은 공간을 차지하도록 `압축`된다. 

```javascript
struct NormalStruct {
  uint a;
  uint b;
  uint c;
}

struct MiniMe {
  uint32 a;
  uint32 b;
  uint c;
}

// `mini`는 구조체 압축을 했기 때문에 `normal`보다 가스를 조금 사용할 것이네.
NormalStruct normal = NormalStruct(10, 20, 30);
MiniMe mini = MiniMe(10, 20, 30); 

이런 이유로, 구조체 안에서는 가능한 한 작은 크기의 정수 타입을 쓰는 것이 좋다.

또한 동일한 데이터 타입은 하나로 묶어놓는 것이 좋다. 즉, 구조체에서 서로 옆에 있도록 선언하면 솔리디티에서 사용하는 저장 공간을 최소화한다. 예를 들면, uint c; uint32 a; uint32 b;라는 필드로 구성된 구조체가 uint32 a; uint c; uint32 b; 필드로 구성된 구조체보다 가스를 덜 소모한다. uint32 필드가 묶여있기 때문이다.

정리하면 가스 비용을 줄이기 위해서

1. 구조체 안에서 가능한 한 작은 크기의 정수 타입을 쓰도록 한다.
2. 동일한 데이터 타입을 하나로 묶어서 쓴다.

시간 단위

솔리디티는 시간을 다룰 수 있는 단위계를 기본적으로 제공한다.

now 변수를 쓰면 현재의 유닉스 타임스탬프(1970년 1월 1일부터 지금까지의 초 단위 합) 값을 얻을 수 있다.

참고: 유닉스 타임은 전통적으로 32비트 숫자로 저장된다. 이는 유닉스 타임스탬프 값이 32비트로 표시가 되지 않을 만큼 커졌을 때 많은 구형 시스템에 문제가 발생할 "Year 2038" 문제를 일으킬 것이다. 그러니 만약 DApp이 지금부터 20년 이상 운영되길 원한다면, 우리는 64비트 숫자를 써야 할 것이다. 하지만 우리 유저들은 그동안 더 많은 가스를 소모해야 하니까, 설계를 보고 결정을 해야 함!

솔리디티는 또한 seconds, minutes, hours, days, weeks, years 같은 시간 단위 또한 포함하고 있다. 이들은 그에 해당하는 길이 만큼의 초 단위 uint 숫자로 변환된다. 즉 1 minutes는 60, 1 hours는 3600(60초 x 60 분), 1 days는 86400(24시간 x 60분 x 60초) 같이 변환된다.

uint lastUpdated;

// `lastUpdated`를 `now`로 설정
function updateTimestamp() public {
  lastUpdated = now;
}

// 마지막으로 `updateTimestamp`가 호출된 뒤 5분이 지났으면 `true`를, 5분이 아직 지나지 않았으면 `false`를 반환
function fiveMinutesHavePassed() public view returns (bool) {
  return (now >= (lastUpdated + 5 minutes));
}

View 함수 이용해 가스 절약하기

View 함수는 가스를 소모하지 않는다.

view 함수는 사용자에 의해 외부에서 호출되었을 때 가스를 전혀 소모하지 않는다.

• 이건 view 함수가 블록체인 상에서 데이터를 읽기만 하지 실제로 어떤 것도 수정하지 않기 때문이다.
• 함수에 view 표시를 하는 것은 web3.js에 로컬 이더리움 노드에 질의만 날리면 되고, 블록체인에 어떤 트랜잭션도 만들지 않는다는걸 알려주는 것과 같다.
• 가능한 모든 곳에 읽기 전용의 external view 함수를 쓰는 것은 사용자들을 위해 DApp의 가스 사용을 최적화하는 비결!

참고: 만약 view 함수가 동일 컨트랙트 내에 있는, view 함수가 아닌 다른 함수에서 내부적으로 호출될 경우, 여전히 가스를 소모한다. 이것은 다른 함수가 이더리움에 트랜잭션을 생성하고, 이는 모든 개별 노드에서 검증되어야 하기 때문이다. 그러니 view 함수는 외부에서 호출됐을 때에만 무료!

Storage는 비싸다

storage 쓰기는 비싼 연산!

• 데이터의 일부를 쓰거나 바꿀 때마다, 블록체인에 영구적으로 기록되기 때문에 이 연산이 굉장히 비싸다.

• 비용을 최소화하기 위해서, 진짜 필요한 경우가 아니면 storage에 데이터를 쓰지 않는 것이 좋다.

• 이를 위해 때때로는 겉보기에 비효율적으로 보이는 프로그래밍 구성을 할 필요가 있다.

• 어떤 배열에서 내용을 빠르게 찾기 위해, 단순히 변수에 저장하는 것 대신 함수가 호출될 때마다 배열을 memory에 다시 만드는 것처럼!

대부분의 프로그래밍 언어에서는, 큰 데이터 집합의 개별 데이터에 모두 접근하는 것은 비용이 비싸다. 하지만 솔리디티에서는 그 접근이 external view 함수라면 storage를 사용하는 것보다 더 저렴한 방법이네. view 함수는 사용자들의 가스를 소모하지 않기 때문이다.

메모리에 배열 선언하기

Storage에 아무것도 쓰지 않고도 함수 안에 새로운 배열을 만들려면 배열에 memory 키워드를 쓰면 된다. 이 배열은 함수가 끝날 때까지만 존재할 것이고, 이는 storage의 배열을 직접 업데이트하는 것보다 가스 소모 측면에서 훨씬 저렴하다. 이게 외부에서 호출되는 view 함수라면 무료!

메모리에 배열을 선언하는 방법은 다음과 같다.

function getArray() external pure returns(uint[]) {
  // 메모리에 길이 3의 새로운 배열을 생성한다.
  uint[] memory values = new uint[](3);
  // 여기에 특정한 값들을 넣는다.
  values.push(1);
  values.push(2);
  values.push(3);
  // 해당 배열을 반환한다.
  return values;
}

참고: 메모리 배열은 반드시 길이 인수와 함께 생성되어야 한다(이 예시에서는, 3). 메모리 배열은 현재로서는 storage 배열처럼 array.push()로 크기가 조절되지는 않는다.

for 반복문

배열이 수정될 때마다 storage를 갈아치우는건 너무 많은 가스 비용을 소진한다. 따라서 배열 안에 있는 원소를 for문을 이용해 가져와 Memory에 저장해서 아용하는 연산을 이용한다.

function getEvens() pure external returns(uint[]) {
  uint[] memory evens = new uint[](5);
  // 새로운 배열의 인덱스를 추적하는 변수
  uint counter = 0;
  // for 반복문에서 1부터 10까지 반복함
  for (uint i = 1; i <= 10; i++) {
    // `i`가 짝수라면...
    if (i % 2 == 0) {
      // 배열에 i를 추가함
      evens[counter] = i;
      // `evens`의 다음 빈 인덱스 값으로 counter를 증가시킴
      counter++;
    }
  }
  return evens;
}

문제 해석

문제

한 개의 회의실이 있는데 이를 사용하고자 하는 N개의 회의에 대하여 회의실 사용표를 만들려고 한다. 각 회의 I에 대해 시작시간과 끝나는 시간이 주어져 있고, 각 회의가 겹치지 않게 하면서 회의실을 사용할 수 있는 회의의 최대 개수를 찾아보자. 단, 회의는 한번 시작하면 중간에 중단될 수 없으며 한 회의가 끝나는 것과 동시에 다음 회의가 시작될 수 있다. 회의의 시작시간과 끝나는 시간이 같을 수도 있다. 이 경우에는 시작하자마자 끝나는 것으로 생각하면 된다.

입력

첫째 줄에 회의의 수 N(1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N+1 줄까지 각 회의의 정보가 주어지는데 이것은 공백을 사이에 두고 회의의 시작시간과 끝나는 시간이 주어진다. 시작 시간과 끝나는 시간은 231-1보다 작거나 같은 자연수 또는 0이다.

출력

첫째 줄에 최대 사용할 수 있는 회의의 최대 개수를 출력한다.

문제 풀이

무식하게 풀 수 있을까?

무식하게 풀기 - 회의실 사용 가능한 모든 경우의 수 중 가장 많은 경우를 출력한다. 회의 수가 10만이나 입력되기 때문에 아마 모든 경우를 구하기는 메모리제한이 있어서 어려울 것 같다.,

💰그리디 알고리즘 이용

💰 그리디 알고리즘이란? 답을 여러 조각으로 쪼개고, 각 단계마다 지금 당장 가장 좋은 방법만을 선택하는 알고리즘

많은 경우 해를 찾아낼 수 없음, 제한된 경우에서만 사용된다.

그럼에도 그리디 알고리즘을 사용하는 이유? 동적 계획법이나 완전 탐색법보다 훨씬 빠르기 때문에! 속도가 빨라서 그냥 이거 쓸 수 있으면 쓰는게 좋다..

그리디 알고리즘 사용되는 경우

1. 탐욕법을 사용해도 항상 최적해를 구할 수 있는 문제를 만난 경우 

2. 시간이나 공간적 제약으로 인해 최적해를 찾기 너무 어려우면 그냥 대충 탐욕법으로 괜찮은 답을 찾음

✨ 그리디 알고리즘의 정당성 증명

탐욕적인 알고리즘이 항상 최적해를 찾아낼 수 있다는 것을 아래 두가지 속성을 증명함으로써 보일 수 있다!

1. 탐욕적 선택 속성

각 단계에서 탐욕적으로 내리는 선택이 항상 최적해로 가는 길 중 하나이며, 탐욕적 선택이 손해가 없다!를 증명

가장 종료 시간이 빠른 회의를 포함하는 최적해가 반드시 존재한다.

• 가장 일찍 끝나는 회의를 선택해서 최적해를 얻는 것이 불가능해지는 경우는 없음!

2. 최적 부분 구조

• 부분 문제의 최적해에서 전체 문제의 최적해를 만들 수 있음을 증명 대개 자명해서 따로 증명할 필요가 없음!

그리디 알고리즘을 이용한 풀이 구성

구상하기

회의실 배정이 가장 많은 경우는 회의시간이 짧은 회의부터 착착 배정하면 가장 많은 회의를 찾을 수 있을 것 같음

1. 제일 가까운 시간이면서

2. 회의시간이 짧은 회의

따라서, 가장 가까운 시간에 시작하는 회의 중 끝나는 시간이 제일 빠른 회의를 선택! 시간만으로 회의실을 배정하는 경우는 아래처럼 되어 해답을 찾을 수 없다.

• 짧은 하나의 회의를 긴 두회의 대신 잡아버림,,
• 그럴듯하다고 해서 정답이 아니라 쓰기가 까다로움.. 0.ㅠ 항상 정당성 증명이 필요하다!

구현하기

✨ 한 회의를 선택할 때마다 겹치는 회의 모두 제거하는 방법

1. 모든 회의를 종료시간 오름차순으로 정렬
2. 정렬된 회의를 순회하면서 앞 회의와 겹치지 않는 회의 찾기

💡 오름차순 정렬 - Java Arrays.sort 고치기!

sort 방식 커스텀하는 방법은 크게 두가지!

1. Comparable 을 class에 implememt 한 후, compateTo 메소드를 override

2. sort내부에서 comparator를 사용하고, compare메소드를 override

나는 2번이 편해서 2번을 선택해서 풀이를 진행했다.

Comparator 정의

• 정렬 가능한 클래스들의 기본 정렬 기준과 다르게 정렬하고 싶을 때 사용하는 인터페이스

• package: java.util.Comparator

• 주로 익명 클래스로 사용됨

• 기본 정렬 방법인 오름차순 정렬을 내림차순으로 정렬할 때 많이 사용

Comparator 구현 방법

1. comparator interface를 implements

2. compare() 메서드 오버라이드 한 myComparator class 작성

   --> 익명 클래스로도 작성 가능, 아래 코드에서는 익명 클래스로 작성하였음

compare() 메소드 작성법

1. 첫번째 파라미터로 넘어온 객체 < 두번째 파라미터로 넘어온 객체: 음수 리턴

2. 첫번째 파라미터로 넘어온 객체 == 두번째 파라미터로 넘어온 객체: 0리턴

3. 첫번째 파라미터로 넘어온 객체 > 두번째 파라미터로 넘어온 객체: 양수 리턴

✨ 음수 또는 0이면 객체 자리 유지되며, 양수인 경우 두 객체의 자리가 변경된다.

    Arrays.sort(timetable, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if (o1[1] == o2[1]) {
                    return o1[0] - o2[0];
                }

                return o1[1] - o2[1];
            }
        });

• o1[1]==o2[1] : 두개 끝나는 시간이 같을 경우

• return o1[0] - o2[0] 1) o1의 시작하는 시간이 더 빠르면 음수 --> 둘의 위치 바뀌지 않음, 2) o1의 시작하는 시간이 더 크면 양수 --> 둘의 위치 바뀜  --> 더 시작시간이 빠른 게 앞으로 정렬됨

• return o1[1] - o2[1] 두개 끝나는 시간 비교해서 o1이 더 빨리 끝날 경우 자리 변경 없고, 더 늦게 끝날 경우 o2와 자리 바뀜

문제 풀이 코드

package Greedy;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class BOJ1931 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int N = s.nextInt();
        int[][] timetable = new int[N][2];
        for (int i = 0; i < N; i++) {
            timetable[i][0] = s.nextInt();
            timetable[i][1] = s.nextInt();
        }

        //timetable 정렬 다시 정의
        Arrays.sort(timetable, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if (o1[1] == o2[1]) {
                    return o1[0] - o2[0];
                }

                return o1[1] - o2[1];
            }
        });

        int result = 0;
        int end_time = 0;
        for (int i = 0; i < N; i++) {
            if (timetable[i][0] >= end_time) {
                end_time = timetable[i][1];
                result++;
            }
        }
        System.out.println(result);


    }
}

문제 해석

문제

준규가 가지고 있는 동전은 총 N종류이고, 각각의 동전을 매우 많이 가지고 있다.

동전을 적절히 사용해서 그 가치의 합을 K로 만들려고 한다. 이때 필요한 동전 개수의 최솟값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N과 K가 주어진다. (1 ≤ N ≤ 10, 1 ≤ K ≤ 100,000,000)

둘째 줄부터 N개의 줄에 동전의 가치 Ai가 오름차순으로 주어진다. (1 ≤ Ai≤ 1,000,000, A1= 1, i ≥ 2인 경우에 Ai는 Ai-1의 배수)

출력

첫째 줄에 K원을 만드는데 필요한 동전 개수의 최솟값을 출력한다.

문제 풀이

무식하게 풀 수 있을까?

무식하게 풀 수 있을 것 같다! 가장 적게 동전을 사용하면 되는 문제이므로,

1. 입력 중 가장 큰 값부터 검사해서 만들어야 하는 값보다 화폐가 작으면 마이너스, 아니면 인덱스를 줄임!
2. 마이너스 할 때마다 동전 개수 count 올리기
3. 0 될때까지 반복 후 마지막에 count 출력

무식하게 풀었음!

💰 그리디 알고리즘 이용

🍕 Greedy Algorithm은 문제를 해결하는 과정에서 그 순간순간마다 최적이라고 생각되는 결정을 하는 방식으로 진행하여 최종 해답에 도달하는 문제 해결 방식이다.

그리디 알고리즘은 아래 두 조건이 충족되었을 때 잘 작동한다.

1. 탐욕스러운 선택 조건

• 앞의 선택이 이후의 선택에 영향을 주지 않는다.

2. 최적 부분 구조 조건

• 문제에 대한 최종 해결 방법이 부분 문제에 대해서도 또한 최적 문제 해결 방법이다.

풀이는 아래 두가지 방법을 이용!

1. 가장 큰 액수부터 계산!
2. 나누는 돈 / 현재 지폐 에서 몫은 지폐 사용량, 나머지는 다음 화폐로 나눌 금액이 된다.

import java.io.FileInputStream;
import java.util.*;
import java.util.stream.*;

class Main {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(new FileInputStream("input.txt"));
        // Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        int M = sc.nextInt();
        int count =0;
        int[] arr=  new int[N];
        for(int i=0; i<N; i++){
            arr[i] = sc.nextInt();
        }

        for(int i = N-1; i>=0; i--){
            if(M>=arr[i]){
                count += M/arr[i];
                M = M%arr[i];
            }

        }

        System.out.println(count);


    }

}

문제 풀이 코드

package Greedy;

import java.util.Scanner;

public class BOJ11047 {
    static int[] wallet;
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int N = s.nextInt();
        int K = s.nextInt();

        wallet = new int[N];
        for (int i = 0; i < N; i++) {
            wallet[i] = s.nextInt();
        }

        int index = N-1;
        int count = 0;
        while (true) {
            if(K==0) break;
            if (K < wallet[index]) {
                index = index - 1;
            }
            else {
                K = K - wallet[index];
                count = count + 1;
            }
        }
        System.out.println(count);
    }
}

📝 List

순서가 있는 데이터의 집합, 데이터의 중복을 허용함 (순서가 있으니까 중복 상관없음!)

LinkedList

• get(index), set(index, element), add(index, elelment), remove(index), peek(), peekLast(), push(e), pop(), size(), clear()

• removeFirst(), removeLast(), addFirst(element), addLast(element)

Stack

• LIFO 구조

• push(), pop(), peek(), search()

Vector: 동기화 보장

• addElement()

• elementAt()

• size()

• insertElementAt()

• setElementAt()

• indexOf() : 데이터 검사해서 index 반환

• contains() : 데이터 존재 유무 검사

ArrayList: 동기화 보장되지 않음

• add(), get(), size, toArray(), contains(), size()

📦 Set

순서를 유지하지 않는 데이터의 집합, 데이터의 중복을 허용하지 않음 (순서 없으니까 중복 허용하면 구분을 못함!)

HashSet

• add(), next(), remove(), contains(), size()

TreeSet: 정렬을 위한 Set계열 클래스(SortedSet 인터페이스 구현)

• 사용자가 직접 정렬 방식 지정

• 정렬을 위한 comparator 인터페이스 구현하면 정렬 방식 지정 가능

• 아무 설정 하지 않고 데이터를 넣으면 기본적으로 오름차순 정렬 --> comparator 인터페이스 구현으로 수정해야 함

🗂 Map interface - 키와 값으로 데이터 핸들

🔖 Hashtable

key와 value의 쌍으로 이루어진 데이터의 집합, 순서 유지 X, 키 중복 X, 값 중복은 가능

HashMap

• put(), get(key)

TreeMap:  SortedMap

• 사용자가 직접 정렬 방식을 지정해서 구현

문제 해석

상담원으로 일하고 있는 백준이는 퇴사를 하려고 한다.

오늘부터 N+1일째 되는 날 퇴사를 하기 위해서, 남은 N일 동안 최대한 많은 상담을 하려고 한다. 백준이는 비서에게 최대한 많은 상담을 잡으라고 부탁을 했고, 비서는 하루에 하나씩 서로 다른 사람의 상담을 잡아놓았다.

각각의 상담은 상담을 완료하는데 걸리는 기간 Ti와 상담을 했을 때 받을 수 있는 금액 Pi로 이루어져 있다.

N = 7인 경우에 다음과 같은 상담 일정표를 보자.

1일에 잡혀있는 상담은 총 3일이 걸리며, 상담했을 때 받을 수 있는 금액은 10이다. 5일에 잡혀있는 상담은 총 2일이 걸리며, 받을 수 있는 금액은 15이다.

상담을 하는데 필요한 기간은 1일보다 클 수 있기 때문에, 모든 상담을 할 수는 없다. 예를 들어서 1일에 상담을 하게 되면, 2일, 3일에 있는 상담은 할 수 없게 된다. 2일에 있는 상담을 하게 되면, 3, 4, 5, 6일에 잡혀있는 상담은 할 수 없다.

또한, N+1일째에는 회사에 없기 때문에, 6, 7일에 있는 상담을 할 수 없다. 퇴사 전에 할 수 있는 상담의 최대 이익은 1일, 4일, 5일에 있는 상담을 하는 것이며, 이때의 이익은 10+20+15=45이다.

상담을 적절히 했을 때, 백준이가 얻을 수 있는 최대 수익을 구하는 프로그램을 작성하시오.

문제 풀이

무식하게 풀 수 있는가?

무식하면 못푸는 문제 같은데 항상 무식하게 풀기부터 도전.. 스택을 어찌어찌 잘 이용해서 max값 찾으면 될지도 모르겠다. 근데 그게 dp로 짜는거보다 쉬운지도 모르겠다.. 그냥 dp로 풀기로 했음

다이나믹 프로그래밍으로 풀기!

💡다이나믹 프로그래밍은 메모이제이션이 핵심!

✨ 메모이제이션이란?
메모이제이션(memoization)은 컴퓨터 프로그램이 동일한 계산을 반복해야 할 때, 이전에 계산한 값을 메모리에 저장함으로써 동일한 계산의 반복 수행을 제거하여 프로그램 실행 속도를 빠르게 하는 기술이다.

1️⃣ 무엇을 메모하면 좋을까?

마감 기한을 고려하는게 핵심인 알고리즘이니까, 마감 날짜를 메모한다! 아래와 같이 기록!

memo[1] = 10
memo[2] = 30
memo[3] = 40
.
.
.
memo[8] = 90

memo[8]에는 8일까지 일했을 때의 최대 액수를 기록한다!

2️⃣ 마감 기한에 따른 최대 액수를 어떤 식으로 저장할 수 있을까?

아래 두가지 조건을 고려!

• 마감된 날짜가 같을 수는 없다.
• 하루도 안쉬고 일하는 것보다 띄엄띄엄 일하는 경우의 수익이 더 높을 수도 있다.

1. 마감된 날짜가 같을 수는 없다.

memo[pay[i][0]+i] = max(memo[pay[i][0]+i],pay[i][1]+memo[i]);

마감된 날짜가 같을 수는 없으니 해당 날짜의 페이는 아래 두가지 경우이다.

1) 해당 마감일에 원래 저장되어있던 pay 2) 오늘 pay, 오늘 마감인 과제 pay더한 값

더 큰 값을 저장해야 하므로, max를 써서 둘 중 더 큰 값을 출력

2. 하루도 안쉬고 일하는 것보다 띄엄띄엄 일하는 경우의 수익이 더 높을 수 있다.

memo[i] = max(memo[i], max);
max = max(max, memo[i]);

i일 까지 일했을 때 최대값은 다음 두가지 경우 중 하나이다.

1) i일 까지 꽉 채워서 일한 경우 2) i일에 일하지 않은 경우

따라서 memo[i]나 이전 저장된 값인 max 중 더 큰 값을 memo한다.

문제 풀이 코드

package DP;

import java.util.Scanner;

import static java.lang.Math.max;

public class BOJ14501 {
    static int[][] pay;
    static int day;
    static int[] memo;
    static int max = 0;
    public static void main(String[] args) {
        //입력 배열로 정돈해서 받기
        Scanner s = new Scanner(System.in);
        day = s.nextInt();
        pay = new int[day + 10][2];
        for (int i = 1; i < day+1; i++) {
            pay[i][0] = s.nextInt();
            pay[i][1] = s.nextInt();
        }
        //메모 선언
        memo = new int[day + 10];
        //DP돌림
        DP(pay);
    }
    static void DP(int[][] pay) {
        for (int i = 1; i <=day+1; i++) {
            //이전까지의 최대 수입을 비교해서 최대 수입을 현재에도 저장해준다.
            //이전에 최대수입이 났을 수 있으므로
            //ex) 3,7,(5 예상) 이라고 하면 5의 값은 7로 바꿔주는게 최대수입을 얻는데 맞다.
            memo[i] = max(memo[i], max);
            //이전에 저장된 최대수익 vs 이번 움직임으로 생긴 최대 수익
            memo[pay[i][0]+i] = max(memo[pay[i][0]+i],pay[i][1]+memo[i]);
            //출력될 최대 수입
            max = max(max, memo[i]);
        }
        System.out.println(max);
    }

}

문제 해석

상근이는 요즘 설탕공장에서 설탕을 배달하고 있다. 상근이는 지금 사탕가게에 설탕을 정확하게 N킬로그램을 배달해야 한다. 설탕공장에서 만드는 설탕은 봉지에 담겨져 있다. 봉지는 3킬로그램 봉지와 5킬로그램 봉지가 있다.

상근이는 귀찮기 때문에, 최대한 적은 봉지를 들고 가려고 한다. 예를 들어, 18킬로그램 설탕을 배달해야 할 때, 3킬로그램 봉지 6개를 가져가도 되지만, 5킬로그램 3개와 3킬로그램 1개를 배달하면, 더 적은 개수의 봉지를 배달할 수 있다.

상근이가 설탕을 정확하게 N킬로그램 배달해야 할 때, 봉지 몇 개를 가져가면 되는지 그 수를 구하는 프로그램을 작성하시오.

문제 풀이

무식하게 풀 수 있는가?

💡 완전 탐색으로 풀기! 설탕 봉지 개수를 기록하며 풀었다.

1️⃣ 어떤 것을 메모하면 좋을까?

문제에서 "최대한 적은 봉지" 수를 찾아야 한다고 했으므로 한번에 최대한 많은 용량의 봉지, 즉 5킬로짜리 봉지를 담아야 한다. 따라서 5킬로짜리 봉지 개수 메모를 배열로 만들고, 3킬로짜리 봉지 개수를 메모하기로 했다.

2️⃣ 메모 형태는 어떻게?

5킬로짜리 봉지의 개수를 배열의 index로! 배열의 값은 3킬로짜리 봉지의 값으로 설정했다.

5[0] = 3 //5킬로 봉지 0개, 3킬로 봉지 3개
5[1] = 2 //5킬로 봉지 1개, 3킬로 봉지 2개
5[2] = -1 //5킬로 봉지 2개를 써서 해당 설탕 무게를 맞출 수 없음

문제에서 5킬로와 3킬로짜리 봉지로 해당 설탕 크기를 나를 수 없다면 -1을 출력하라고 했기 때문에 배열의 초기값을 -1로 설정했다.

3️⃣ 적당한 메모장 크기 찾기

11킬로짜리 설탕을 나르는 데 5킬로 봉지는 최대 2개 필요하므로 입력 최대 크기인 5000/5 = 1000, 길이 1000의 배열을 만들 필요가 없다. 따라서 입력받은 수를 5로 나눈 몫보다 하나 큰 크기의 배열을 생성해 -1로 초기화하도록 했다.

4️⃣ 설탕 봉지 개수 구하기

1. 우선 5킬로 봉지를 입력값에서 뺀다.
2. 남은 입력값을 3으로 나눠 나머지가 0이면 몫을 메모
3. 나머지가 0이 아닐 경우 continue

문제 풀이 코드

package DP;

import java.util.Scanner;

import static java.lang.Math.min;

public class BOJ2839 {
    static int sugar;
    static int memo[];

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        sugar = s.nextInt();
        //배열 크기 정하기
        int length = sugar / 5;

        //메모 배열 초기화
        memo = new int[length+1];
        for (int i = 0; i <= length; i++) {
            memo[i] = -1;
        }

        //메모하기
        for (int i = 0; i <= length; i++) {
            int temp = sugar - (5 * i);
            if (temp % 3 == 0) {
                memo[i] = temp / 3;
            }
        }

        //배열 최소값 찾기
        int min = 1001;
        int index = 0;
        for (int i = 0; i <= length; i++) {
            if (memo[i] != -1) {
                int lastmin = min;
                min = min(min, memo[i]);
                if (lastmin != min) {
                    index = i;
                }
            }
        }
        //최소 값 출력
        if (min == 1001) {
            System.out.println(-1);
        }
        else{
            System.out.println(min + index);
        }

    }
}

✍🏻 코드 분석

매핑과 주소

주소

이더리움 블록체인은 은행 계좌와 같은 계정들로 이루어져 있다. 계정은 이더리움 블록체인상의 통화인 _이더_의 잔액을 가진다. 은행 계좌에서 다른 계좌로 돈을 송금할 수 있듯이, 계정을 통해 다른 계정과 이더를 주고 받을 수 있다. 각 계정은 은행 계좌 번호와 같은주소를 가지고 있다. 주소는 특정 계정을 가리키는 고유 식별자로, 아래와 같이 표현된다.

0x0cE446255506E92DF41614C46F1d6df9Cc969183

"주소는 특정 유저(혹은 스마트 컨트랙트)가 소유한다"라는 점이 핵심! 따라서, 주소를 자원에 대한 소유권을 나타내는 고유 ID로 활용할 수 있다.

매핑

솔리디티에서 구조화된 데이터를 저장하는 방법이다. 매핑은 다음과 같이 사용할 수 있다.

//기본형
mapping(key => value) mapping_name;

// 금융 앱용으로, 유저의 계좌 잔액을 보유하는 uint를 저장한다.
mapping (address => uint) public accountBalance; 

// 혹은 userID로 유저 이름을 저장/검색하는 데 매핑을 쓸 수도 있다.
mapping (uint => string) userIdToName;

매핑은 기본적으로 키-값 (key-value) 저장소로, 데이터를 저장하고 검색하는 데 이용된다. 첫번째 예시에서 키는address이고 값은uint이다. 두번째 예시에서 키는uint이고 값은string이다.

Msg.sender

솔리디티에는 모든 함수에서 이용 가능한 특정 전역 변수들이 있다. 그 중의 하나가 현재 함수를 호출한 사람 (혹은 스마트 컨트랙트)의 주소를 가리키는msg.sender!

참고: 솔리디티에서 함수 실행은 항상 외부 호출자가 시작한다. 컨트랙트는 누군가가 컨트랙트의 함수를 호출할 때까지 블록체인 상에서 아무 것도 안 하고 있을 것이니 항상msg.sender가 있어야 한다.

Mapping을 아래와 같이 msg.sender가 이용할 수 있다.

mapping (address => uint) favoriteNumber;

function setMyNumber(uint _myNumber) public {
  // `msg.sender`에 대해 `_myNumber`가 저장되도록 `favoriteNumber` 매핑을 업데이트한다 `
  favoriteNumber[msg.sender] = _myNumber;
  // ^ 데이터를 저장하는 구문은 배열로 데이터를 저장할 떄와 동일하다 
}

function whatIsMyNumber() public view returns (uint) {
  // sender의 주소에 저장된 값을 불러온다 
  // sender가 `setMyNumber`을 아직 호출하지 않았다면 반환값은 `0`이 될 것이다
  return favoriteNumber[msg.sender];
}

Key값을 []안에 넣고, value를 할당하는 형식으로 작동한다! msg.sender는 현재 함수를 호출한 사람의 주소를 담고 있으므로 mapping의 Key인 address형이 된다.

require

특정 조건이 참이 아닐 때 함수가 에러 메세지를 발생하고 실행을 멈추게 한다. 보통 한 노드가 함수를 한 번 호출하는 데에 쓰임!

function sayHiToVitalik(string _name) public returns (string) {
  // _name이 "Vitalik"인지 비교한다. 참이 아닐 경우 에러 메시지를 발생하고 함수를 벗어난다
  // (참고: 솔리디티는 고유의 스트링 비교 기능을 가지고 있지 않기 때문에 
  // 스트링의 keccak256 해시값을 비교하여 스트링 값이 같은지 판단한다)
  require(keccak256(_name) == keccak256("Vitalik"));
  // 참이면 함수 실행을 진행한다:
  return "Hi!";
}

 require(ownerZombieCount[msg.sender]==0);

이런 구문이 있으면 저 ownerZombieCount의 값이 0이 아닐 경우 에러 메세지가 출력되고, 함수가 작동되지 않는다.

상속

contract Doge {
  function catchphrase() public returns (string) {
    return "So Wow CryptoDoge";
  }
}

contract BabyDoge is Doge {
  function anotherCatchphrase() public returns (string) {
    return "Such Moon BabyDoge";
  }
}

문법 진짜 이상하다.. 저 is 가 implements와 같은 기능을 함! 위 코드에 따르면 baby doge는 doge의 모든 public 함수 접근 가능!

저장 공간

storage == HDD

블록체인 상에 영구적으로 저장되는 변수 상태 변수(함수 외부 선언 변수)는 초기 설정상 storage로 선언됨 포인터로 사용되는 변수를 선언한다!

memory == RAM

임시적으로 저장되는 변수, 컨트랙트 함수에 대한 외부 호출들이 일어나는 사이에 지워짐 함수 내에 선언된 변수는 자동으로 Memory로 선언됨  단순히 temp 변수로 사용된다!

💡 두개 지정은 구조체와 배열을 처리할 때 사용! 평소에는 솔리디티가 자동으로 해준다.

contract SandwichFactory {
  struct Sandwich {
    string name;
    string status;
  }

  Sandwich[] sandwiches;

  function eatSandwich(uint _index) public {
    // Sandwich mySandwich = sandwiches[_index];

    // ^ 꽤 간단해 보이나, 솔리디티는 여기서 
    // `storage`나 `memory`를 명시적으로 선언해야 한다는 경고 메시지를 발생한다. 
    // 그러므로 `storage` 키워드를 활용하여 다음과 같이 선언해야 한다:
    Sandwich storage mySandwich = sandwiches[_index];
    // ...이 경우, `mySandwich`는 저장된 `sandwiches[_index]`를 가리키는 포인터이다.
    // 그리고 
    mySandwich.status = "Eaten!";
    // ...이 코드는 블록체인 상에서 `sandwiches[_index]`을 영구적으로 변경한다. 

    // 단순히 복사를 하고자 한다면 `memory`를 이용하면 된다: 
    Sandwich memory anotherSandwich = sandwiches[_index + 1];
    // ...이 경우, `anotherSandwich`는 단순히 메모리에 데이터를 복사하는 것이 된다. 
    // 그리고 
    anotherSandwich.status = "Eaten!";
    // ...이 코드는 임시 변수인 `anotherSandwich`를 변경하는 것으로 
    // `sandwiches[_index + 1]`에는 아무런 영향을 끼치지 않는다. 그러나 다음과 같이 코드를 작성할 수 있다: 
    sandwiches[_index + 1] = anotherSandwich;
    // ...이는 임시 변경한 내용을 블록체인 저장소에 저장하고자 하는 경우이다.
  }
}

상속 관계 함수 접근

private를 internal로 바꾸어 선언하면 함수가 정의된 컨트랙트를 상속하는 컨트랙트에서도 접근 가능하다!

다른 컨트랙트와 상호작용하기 - interface 이용

인터페이스 정의

블록체인 상에 있으면서 우리가 소유하지 않은 컨트랙트와 우리 컨트랙트가 상호작용을 하려면 우선 인터페이스를 정의해야 한다.

다음과 같은 블록체인 컨트랙트가 있다고 가정해보자.

contract LuckyNumber {
  mapping(address => uint) numbers;

  function setNum(uint _num) public {
    numbers[msg.sender] = _num;
  }

  function getNum(address _myAddress) public view returns (uint) {
    return numbers[_myAddress];
  }
}

이 컨트랙트는 아무나 자신의 행운의 수를 저장할 수 있는 간단한 컨트랙트이고, 각자의 이더리움 주소와 연관이 있을 것이다. 이 주소를 이용해서 누구나 그 사람의 행운의 수를 찾아 볼 수 있게 public으로 모든 함수가 정의되어있다.

이제getNum함수를 이용하여 이 컨트랙트에 있는 데이터를 읽고자 하는 external 함수가 있다고 해 보자. 먼저,LuckyNumber 컨트랙트의 인터페이스를 정의할 필요가 있다.

contract NumberInterface {
  function getNum(address _myAddress) public view returns (uint);
}

인터페이스는 자바 인터페이스 정의하듯이 하면 된다! 시작이 interface가 아니라 contract!!!!! 여기서는 인터페이스를 정의하는 것이 컨트랙트를 정의하는 것과 유사하다는 걸 참고해야 한다. 먼저, 다른 컨트랙트와 상호작용하고자 하는 함수만을 선언할 뿐 다른 함수나 상태 변수를 언급하지 않는다. 다음으로, 함수 몸체를 정의하지 않는다. 중괄호{,}를 쓰지 않고 함수 선언을 세미콜론(;)으로 간단하게 끝낸다. 그러니 인터페이스는 컨트랙트 뼈대처럼 보인다고 할 수 있다.  우리의 dapp 코드에 이런 인터페이스를 포함하면 컨트랙트는 다른 컨트랙트에 정의된 함수의 특성, 호출 방법, 예상되는 응답 내용에 대해 알 수 있게 된다.

다수의 반환값 처리

또 참고하면 좋은게, 다른 프밍 언어들과 다르게 솔리디티는 함수가 하나 이상의 값을 반환할 수 있다!

function multipleReturns() internal returns(uint a, uint b, uint c) {
  return (1, 2, 3);
}

function processMultipleReturns() external {
  uint a;
  uint b;
  uint c;
  // 다음과 같이 다수 값을 할당한다:
  (a, b, c) = multipleReturns();
}

// 혹은 단 하나의 값에만 관심이 있을 경우: 
function getLastReturnValue() external {
  uint c;
  // 다른 필드는 빈칸으로 놓기만 하면 된다: 
  (,,c) = multipleReturns();
}

아래처럼 다수 값을 할당해서 처리! 하나의 값만 가져오는 것도 흥미로움.,,,네네

인터페이스 이용

//인터페이스 정의
contract NumberInterface {
  function getNum(address _myAddress) public view returns (uint);
}

//인터페이스 이용
contract MyContract {
  address NumberInterfaceAddress = 0xab38...
  // ^ 이더리움상의 FavoriteNumber 컨트랙트 주소이다
  NumberInterface numberContract = NumberInterface(NumberInterfaceAddress)
  // 이제 `numberContract`는 다른 컨트랙트를 가리키고 있다.

  function someFunction() public {
    // 이제 `numberContract`가 가리키고 있는 컨트랙트에서 `getNum` 함수를 호출할 수 있다:
    uint num = numberContract.getNum(msg.sender);
    // ...그리고 여기서 `num`으로 무언가를 할 수 있다
  }
}

코드 가운데쪽에 보면 인터페이스 numberContract를 선언해 사용한다는걸 알 수 있음! 초기값은 오른쪽 코드처럼 설정한다.

//getkitty는 10개 값을 반환하고, 맨 마지막에 있는 값을 kittyDna에 저장하는 코드

function feedOnKitty(uint _zombieId, uint _kittyId) public {
    uint kittyDna;
    (,,,,,,,,,kittyDna) = kittyContract.getKitty(_kittyId);
    feedAndMultiply(_zombieId, kittyDna);
  }

getkitty는 10개 값을 반환하고, 맨 마지막에 있는 값을 kittyDna에 저장하는 코드이다. 쉼표 진짜 어이없음..

string 동일 여부 판단

 if(keccak256(_species)==keccak256("kitty")){
        newDna = newDna - newDna % 100 + 99;
    }

hash값 비교로 스트링이 한글자한글자 일치하는지 판단 가능! 해시는 입력 값이 조금만 바뀌어도 확 바뀌니까..

크립토 좀비 튜토리얼

Solidity 튜토리얼로는 크립토 좀비가 굉장히 유명하다. 블록체인은 배울 수 있는 곳이 정말정말 적어서 이런게 너무 귀하고 그렇다..네네 튜토리얼 하면서 솔리디티 문법 하나하나 차근차근 배울 수 있어서 좋았다. 솔리디티 문법 자체는 좀 기괴했지만... 어쨌든 크립토 좀비를 하면서 솔리디티 문법 배운 것들을 착착 적어보려 한다.

✍🏻 코드 분석

1. 기본 구조

pragma solidity ^0.4.19;

contract HelloWorld {

}

• 모든 솔리디티 소스 코드는 "version pragma"로 시작해야 하는데, 이는 해당 코드가 이용해야 하는 솔리디티 버전을 선언하는 것이다.
• 솔리디티 코드는 컨트랙트안에 싸여 있다.컨트랙트는 이더리움 애플리케이션의 기본적인 구성 요소로, 모든 변수와 함수는 어느 한 컨트랙트에 속한다. 컨트랙트는 모든 프로젝트의 시작점!

2. 새로운 변수 uint형과 상태 변수

contract Example {
  // 이 변수는 블록체인에 영구적으로 저장된다
  uint myUnsignedInteger = 100;
}

• 컨트랙트 안에서 선언하는 변수는 블록체인에 영구적으로 저장된다. 그래서 조심해야함..!
• uint자료형은 부호 없는 정수로, 값이 음수가 아니어야 한다는 의미. 부호 있는 정수는 int자료형!
• 솔리디티에서 uint는 실제로 uint256, 즉 256비트 부호 없는 정수의 다른 표현이다.uint8, uint16, uint32등과 같이 uint를 더 적은 비트로 선언할 수도 있다. 하지만 특별한 경우 아니면 그냥 uint로 선언!

3. 구조체 선언, 배열 선언

struct Person {
  uint age;
  string name;
}

// 2개의 원소를 담을 수 있는 고정 길이의 배열:
uint[2] fixedArray;
// 또다른 고정 배열으로 5개의 스트링을 담을 수 있다:
string[5] stringArray;
// 동적 배열은 고정된 크기가 없으며 계속 크기가 커질 수 있다:
uint[] dynamicArray;

//구조체 배열
Person[] people; // 이는 동적 배열로, 원소를 계속 추가할 수 있다.

• 자바처럼 구조체, 배열 선언이 가능하다.
• 고정 길이 배열과 동적 배열 둘 다 선언 가능하다.
• 구조체 배열도 선언 가능하다.

Person[] public people;

• 다른 앱에서 접근 가능하도록 하려면 public 배열을 선언해야 한다.

//구조체 배열에 구조체 생성해서 넣기
people.push(Person(16, "Vitalik"));

//배열에 push로 원소 넣기
uint[] numbers;
numbers.push(5);
numbers.push(10);
numbers.push(15);
// numbers 배열은 [5, 10, 15]과 같다.

-array.push()는 무언가를 배열의끝에 추가해서 모든 원소가 순서를 유지하도록 한다.

4. 함수 선언

string greeting = "What's up dog";

//public 함수
function sayHello() public returns (string) {
  return greeting;
}

//pure 함수
function _multiply(uint a, uint b) private pure returns (uint) {
  return a * b;
}

//private 함수
  function _createZombie(string _name, uint _dna) private {
        zombies.push(Zombie(_name, _dna));
}

• pure는 함수가 앱에서 어떤 데이터도 접근하지 않는 것을 의미
• return 타입을 앞에 명시함.. 개이상해
• public, privte은 자바와 똑같음! 외부 앱에 접근 권한을 주냐 마냐 하는 것

5. Keccak256과 형 변환

//6e91ec6b618bb462a4a6ee5aa2cb0e9cf30f7a052bb467b0ba58b8748c00d2e5
keccak256("aaaab");
//b1f078126895a1424524de5321b339ab00408010b7cf0e6ed451514981e58aa9
keccak256("aaaac");

• keccak256: 솔리디티가 내장하고 있는 해시 함수. 주석처리된 값으로 변환시켜줌
• 해시 함수는 기본적으로 입력 스트링을 랜덤 256비트 16진수로 매핑

uint8 a = 5;
uint b = 6;
// a * b가 uint8이 아닌 uint를 반환하기 때문에 에러 메시지가 난다:
uint8 c = a * b; 
// b를 uint8으로 형 변환해서 코드가 제대로 작동하도록 해야 한다:
uint8 c = a * uint8(b); 

• uint 기본은 256비트! uint8은 8비트여서 저 둘이 호환이 안된다.

6. 이벤트 작성

// 이벤트를 선언한다
event IntegersAdded(uint x, uint y, uint result);

function add(uint _x, uint _y) public {
  uint result = _x + _y;
  // 이벤트를 실행하여 앱에게 add 함수가 실행되었음을 알린다:
  IntegersAdded(_x, _y, result);
  return result;
}

• 이벤트는 컨트랙트가 블록체인 상에서 자네 앱의 사용자 단에서 무언가 액션이 발생했을 때 의사소통하는 방법이다. 컨트랙트는 특정 이벤트가 일어나는지 "귀를 기울이고" 그 이벤트가 발생하면 행동을 취하게 된다.

7. web3.js

// 여기에 우리가 만든 컨트랙트에 접근하는 방법을 제시한다:
var abi = /* abi generated by the compiler */
var ZombieFactoryContract = web3.eth.contract(abi)
var contractAddress = /* our contract address on Ethereum after deploying */
var ZombieFactory = ZombieFactoryContract.at(contractAddress)
// `ZombieFactory`는 우리 컨트랙트의 public 함수와 이벤트에 접근할 수 있다.

// 일종의 이벤트 리스너가 텍스트 입력값을 취한다:
$("#ourButton").click(function(e) {
  var name = $("#nameInput").val()
  // 우리 컨트랙트의 `createRandomZombie`함수를 호출한다:
  ZombieFactory.createRandomZombie(name)
})

// `NewZombie` 이벤트가 발생하면 사용자 인터페이스를 업데이트한다
var event = ZombieFactory.NewZombie(function(error, result) {
  if (error) return
  generateZombie(result.zombieId, result.name, result.dna)
})

// 좀비 DNA 값을 받아서 이미지를 업데이트한다
function generateZombie(id, name, dna) {
  let dnaStr = String(dna)
  // DNA 값이 16자리 수보다 작은 경우 앞 자리를 0으로 채운다
  while (dnaStr.length < 16)
    dnaStr = "0" + dnaStr

  let zombieDetails = {
    // 첫 2자리는 머리의 타입을 결정한다. 머리 타입에는 7가지가 있다. 그래서 모듈로(%) 7 연산을 하여
    // 0에서 6 중 하나의 값을 얻고 여기에 1을 더해서 1에서 7까지의 숫자를 만든다. 
    // 이를 기초로 "head1.png"에서 "head7.png" 중 하나의 이미지를 불러온다:
    headChoice: dnaStr.substring(0, 2) % 7 + 1,
    // 두번째 2자리는 눈 모양을 결정한다. 눈 모양에는 11가지가 있다:
    eyeChoice: dnaStr.substring(2, 4) % 11 + 1,
    // 셔츠 타입에는 6가지가 있다:
    shirtChoice: dnaStr.substring(4, 6) % 6 + 1,
    // 마지막 6자리는 색깔을 결정하며, 360도(degree)까지 지원하는 CSS의 "filter: hue-rotate"를 이용하여 아래와 같이 업데이트된다:
    skinColorChoice: parseInt(dnaStr.substring(6, 8) / 100 * 360),
    eyeColorChoice: parseInt(dnaStr.substring(8, 10) / 100 * 360),
    clothesColorChoice: parseInt(dnaStr.substring(10, 12) / 100 * 360),
    zombieName: name,
    zombieDescription: "A Level 1 CryptoZombie",
  }
  return zombieDetails
}

• 이더리움은Web3.js라고 하는 자바스크립트 라이브러리를 가지고 있다.
• 직접 작성한 자바스크립트로 위의zombieDetails에서 생성된 값을 받아 웹 브라우저 기반 자바스크립트의 마법과 같은 기능(우리는 Vue.js를 이용함)을 활용하여 이미지를 변경하고 CSS 필터를 적용할 수 있다.