제가 지금껏 사용해온 Web2 서비스에서의 이탈 지점은 보통 "필요한 서비스가 아니어서", "재미가 없어서" 같은 이유였습니다. "로그인이 어려워서" 서비스를 그만둔 적은 거의 없었던 것 같습니다.

하지만 Web3에서는 이게 충분히 가능한 이탈 사유가 됩니다. 메타마스크 설치, 네트워크 추가, 시드 문구 백업, 가스비 준비까지 요구하면 사용자는 서비스에 들어오기도 전에 지칩니다. 그렇다고 서버가 개인키를 대신 보관하는 Custodial 방식은 보안적 책임이 너무 큽니다.

이번에는 Scafonix MPC 서비스를 사용해 Google 소셜 로그인만으로 테스트넷 지갑을 만들고, 직접 배포한 SimpleCounter 컨트랙트를 호출해봤습니다. Scafonix는 개인키를 P1, P2, P3로 나누는 2-of-3 MPC 방식입니다. 완성된 개인키를 DB에 저장하거나 서버에서 복구한 뒤 서명하는 구조가 아니라, 브라우저의 보안 샌드박스 안에서 필요한 share를 조합해 서명을 수행합니다. 서비스 제공자 입장에서는 별도의 키 보관 DB나 서명 서버를 운영하지 않아도 된다는 점이 가장 크게 와닿았습니다.

Scafonix Docs를 참고하여 이번 데모를 제작해 봤습니다. Scafonix Docs

Scafonix 에서는 AI Agent 가 활용할 수 있는 프롬프트도 지원하기 때문에 어렵지 않게 구현할 수 있습니다. AI Assistant Docs

1. SimpleCounter

테스트할 컨트랙트는 일부러 단순하게 만들었습니다. 사용자별 count만 저장하고, getCount()는 msg.sender의 count를 반환합니다. count()는 같은 msg.sender의 count를 1 증가시킵니다.

2. Google 로그인으로 지갑 연결

아래는 Scafonix 연동데모를 위해 만든 간단한 페이지 입니다.

클라이언트는 프레임워크 없이 HTML과 JS만 사용했습니다. 단 두줄(ethers 연동을 위한 코드라인을 빼면 단 한줄)만으로도 손쉽게 라이브러리를 불러와서 사용할 수 있습니다.

<script src="https://cdnjs.cloudflare.com/ajax/libs/ethers/6.13.1/ethers.umd.min.js"></script>
<script src="https://sdk.scafonix.com/sdk.js?v=2"></script>

Google Login 버튼을 누르면 Google OAuth 팝업이 나와서 구글계정으로 손쉽게 로그인할 수 있습니다.

로그인이 완료되면 별다른 과정 없이 나의 지갑이 생성되었고, 생성된 지갑주소를 확인할 수 있습니다.

Google Login만으로 Scafonix Wallet 연결까지 이어지는 간편한 UX가 구현됐습니다.

3. getCount와 count 호출

getCount()는 view 함수라서 단순히 RPC call로 조회했습니다. 다만 컨트랙트가 msg.sender 기준으로 count를 저장하기 때문에, call을 보낼 때도 Scafonix 지갑 주소를 from으로 넣어 현재 로그인한 사용자의 값을 읽었습니다.

const value = await contract.getCount({ from: connectedEvmAddress });

반면 count()는 실제 상태를 바꾸는 함수라 트랜잭션 서명이 필요합니다. Scafonix를 통해 tx에 서명하고 broadcast되는 과정은 아래 4단계로 이해하면 쉽습니다.

1. 클라이언트에서 unsigned tx를 만든다
   먼저 to, data, chainId, nonce, gasLimit, fee 값을 채워 아직 서명되지 않은 transaction object를 만듭니다. SimpleCounter.count()의 경우 contract.count.populateTransaction()으로 호출 data를 만들고, RPC에서 nonce와 gas 정보를 조회합니다.

2. Scafonix SDK에 서명을 요청한다
   만든 tx object를 Scafonix.signTransaction(connectedEvmAddress, tx)로 넘깁니다. 여기서 넘기는 것은 개인키가 아니라 서명할 트랜잭션 데이터입니다. device에 저장된 키를 Scafonix 서버로 전송해서 복구하는 구조가 아닙니다.

3. SDK 보안 샌드박스에서 MPC 서명이 생성된다
   Scafonix는 P1, P2, P3 중 필요한 share 조합으로 2-of-3 threshold signing을 수행합니다. 문서 기준으로 이 과정에서도 완성된 private key는 메모리 안에서 조립되지 않습니다. EVM의 경우 결과값은 { r, s, v } 형태의 ECDSA signature입니다.

4. 서명을 붙여 raw transaction을 만들고 RPC에 broadcast한다
   반환받은 signature를 ethers의 Transaction.from({ ...tx, signature }).serialized로 붙이면 signed raw transaction이 됩니다. 이 raw transaction을 provider.broadcastTransaction(signedTx)로 네트워크에 전송합니다.

const signature = await Scafonix.signTransaction(connectedEvmAddress, tx);
const signedTx = ethers.Transaction.from({ ...tx, signature }).serialized;
await provider.broadcastTransaction(signedTx);

서비스 제공자가 유저의 개인키를 들고 있지 않은데도, 사용자는 소셜 로그인 이후 자연스럽게 온체인 트랜잭션을 만들 수 있습니다.

4. 백업과 복구

P3는 사용자가 직접 보관하는 복구 share입니다. Google Drive나 copy key share 같은 옵션을 선택할 수 있습니다. 백업 모달은 showBackupModal(userId)로 열 수 있습니다.

Privy와 비교하며 느낀 차이

Privy 같은 Embedded Wallet도 Web3 온보딩 문제를 잘 풀어주는 선택지입니다. 다만 Scafonix는 서비스 제공자 서버 및 DB에 키를 저장하지 않으며, 서명 서버를 두지 않는다는 점이 강점입니다. P1은 브라우저, P2는 소셜 인증 기반 share, P3는 유저가 보관하는 백업 share로 나뉘고, 2-of-3 구조에서 서명이 일어납니다.

물론 "프론트엔드가 해킹돼도 무조건 안전하다"는 뜻은 아닙니다. 악성 트랜잭션 승인, 피싱, 스크립트 공급망 공격은 여전히 별도로 방어해야 합니다. 다만 개인키 전체를 앱이나 서버 및 DB에 저장하지 않는다는 점은 확실히 운영 부담을 줄여줄 수 있다고 생각합니다.

마무리

이번 데모에서는 Scafonix를 연동하여 Google 로그인 한 번으로 지갑 생성부터 연결까지 하고, 직접 배포한 SimpleCounter의 getCount()와 count()까지 호출했습니다. 메타마스크 설치 없이도 온체인 액션을 만들 수 있었고, 서비스 제공자 입장에서는 키를 따로 보관하는 설계를 하지 않아도 되기 때문에 정책적 리스크를 줄일 수 있으며 개별 키 보관 위험도 줄어든다는 점이 좋았습니다. 또한 분리된 키를 따로따로 보관하기 때문에 단일 share 유출만으로는 서명이 불가능하다는 점도 기존 private key 단일 보관 방식보다 안전하게 느껴졌습니다.

Custodial Wallet? Non-Custodial Wallet?

web3 서비스를 이용하다보면 커스터디 월렛, 논-커스터디 월렛이라는 용어를 사용합니다.

Custodial Wallet

서비스 제공자가 사용자의 private key를 대신 보관하고 관리하는 지갑

특징

• 사용자는 private key를 직접 관리하지 않음
• 로그인 기반 (이메일, OAuth 등)으로 접근 가능
• UX가 Web2 서비스처럼 간단함
• 서비스가 계정을 복구하거나 접근을 제한할 수 있음

장점

• 사용하기 쉬움 (초보자 친화적)
• 사용자의 키 분실 리스크 없음
• 빠른 온보딩

단점

• 서비스가 자산을 통제할 수 있음
• 해킹 또는 내부 사고 시 리스크 큼(SPOF)
• “Not your key, not your coin”

Non-Custodial Wallet

Non-Custodial Wallet은 사용자가 자신의 private key를 직접 관리하는 지갑

특징

• private key를 사용자 본인이 보관
• 모든 트랜잭션은 사용자가 직접 서명
• !!누구도!! 계정을 임의로 통제할 수 없음

장점

• 완전한 자산 소유권
• 검열 저항성
• 탈중앙성 유지

단점

• 키 분실 시 복구 불가능
• UX가 어렵고 진입장벽 높음
• gas fee, 네트워크 이해 필요

Account Abstraction : 계정 추상화

AA 는 왜 등장했는가

기존 EOA의 문제점

• 모든 tx는 EOA private key 서명이 필요
• gas fee는 반드시 ETH로만 지불 가능
• ETH Funding이 꼭 필요함
• nonce 관리 강제
• 하나의 private key가 곧 계정 자체
• 서명 정책 커스터마이징 불가능
• recovery / session key / multi-sig 등을 구현하려면 별도 구조 필요

EOA vs Account Abstraction 비교

Definitions : 구성 항목

• UserOperation : 유저 행동을 정의하는 정보를 갖고 있는 데이터 구조체. 흔히 사용하는 transaction과 비슷한 개념이지만 같은 것은 아니기 때문에 UserOperation 이라는 용어 사용

• Sender : 추상화된 하나의 계정. UserOperation을 보내는 계정이며, 일반적으로 스마트 컨트랙트 계정(Account Contract)을 의미함

• Owner : 추상화된 계정의 주인 계정. Sender에 대한 통제권과 소유권을 갖고있음을 증명할 수 있는 계정이며 일반적으로 Private Key를 사용하는 EOA 계정

• EntryPoint : UserOperation을 검증하고 실행하는 중심 컨트랙트. Bundler는 여러 UserOperation을 모아 EntryPoint.handleOps()를 호출하고, EntryPoint는 각 Account의 검증 로직과 실행 로직을 호출함

• Bundler : UserOperation mempool에서 UserOperation들을 수집하고, 이를 하나의 일반 Ethereum transaction으로 묶어 EntryPoint에 제출하는 주체

• Paymaster : 사용자의 gas 비용을 대신 지불하거나, ETH가 아닌 다른 방식으로 gas 비용을 처리할 수 있게 해주는 선택적 컨트랙트. 예를 들어 서비스가 gas를 sponsor하거나, 사용자가 토큰으로 gas 비용을 지불하는 구조를 만들 수 있음

• AccountFactory : Account Contract를 생성하는 컨트랙트. 사용자의 Account가 아직 배포되지 않은 경우, UserOperation의 initCode를 통해 Factory가 Account를 생성할 수 있음

• UserOperation mempool : ERC-4337 표준 검증 규칙을 따르는 공개 UserOperation mempool. Bundler들이 공통 규칙에 따라 UserOperation을 수집하고 검증할 수 있도록 설계된 기본 mempool 개념

• Deposit : EntryPoint에 예치된 ETH 잔액. Account 또는 Paymaster가 gas 비용 정산을 위해 EntryPoint에 미리 예치해두는 자금

AA 동작방식

1. userOperation을 생성합니다.

{
  "sender" : "",
  "nonce" : "",
  "factory" : "",
  "factoryData" : "",
  "callData" : "",
  "callGasLimit" : "",
  "verificationGasLimit" : "",
  "preVerificationGas" : "",
  "maxFeePerGas" : "",
  "maxPriorityFeePerGas" : "",
  "paymaster" : "",
  "paymasterVerificationGasLimit" : "",
  "paymasterPostOpGasLimit" : "",
  "paymasterData" : "",
  "signature" : "",

}

2. 생성된 userOperation의 실행 주체는 sender입니다. sender가 생성한 userOp 이 맞다는 서명을 owner 계정을 통해 생성합니다.

3. 생성된 userOperation 과 signature를 alt_mempool 에 제출합니다.

4. bundler는 alt_mempool에 등록된 userOperation 정보(signature 포함)를 가지고 entryPoint의 handleOps() 함수를 호출합니다.

5. handleOps() 함수는 내부적으로 account contract의 validateUserOp을 통해 userOperation을 검증합니다.

6. paymaster가 지정되었다면 validatePaymasterUserOp을 통해 paymaster도 검증합니다.

7. bundler가 handleOps()를 네트워크에 전송할 때 가스토큰을 지불합니다.

8. userOperation이 실행이 끝나면 사용한 gas 만큼 bundler가 user/paymaster로부터 돌려받습니다.

9. user/paymaster의 deposit에서 돌려받게 되며, atomic하게 정산됩니다.

validateUserOp의 의미

기존 Ethereum 에서는

이 트랜잭션이 유효한, 즉 트랜잭션을 전송하는 사람이 계정의 주인이 맞는지

를 검증하기 위하여 ECDSA 서명 검증 로직이 protocol 내부에 고정되어있습니다. : transaction data 를 생성 -> 계정 소유자가 private key로 서명 -> 프로토콜 레벨에서 ECDSA 서명검증 -> 검증 성공 시 tx 실행

하지만 AA 에서는 이 검증 과정을 원하는 방식으로 직접 구현할 수 있으며 그로 인해 다음 기능들을 구현할 수 있습니다.

• owner signature 검증
• multiSig 검증
• 특정 시간대만 사용 가능
• 특정 dApp만 허용
• 등

기존 Ethereum에서는 “유효한 서명”의 기준이 protocol에 고정되어 있었다면, ERC-4337에서는 그 검증 기준 자체를 Account Contract가 직접 정의할 수 있게 됩니다.

paymaster 예시

gas sponsor

1. 사용자는 ETH 없음
2. 서비스는 Paymaster 운영
3. 사용자는 단순 서명만 수행
4. Paymaster가 gas sponsor
5. 사용자는 Web2처럼 서비스 이용

ERC20 gas payment

사용자는 USDC만 보유

→ Paymaster가 ETH gas를 대신 지불 → 이후 User의 USDC를 차감

AA로 가능한 것들

계정 추상화는 계정들로 하여금 다음을 가능하게 합니다.

• 가스비 대납
• 일반 ERC-20 토큰으로 가스비 지불
• 트랜잭션 배치 실행
• 계정사용정책 적용
• 계정 signer 로테이션
• 등등

마무리

ERC-4337은 단순히 “가스비를 대신 내주는 기술”이 아닙니다.

기존 Ethereum의 EOA는 강력하고 단순했지만, 계정 자체의 동작 방식을 프로그래밍할 수는 없었습니다.

하지만 Account Abstraction에서는 계정(Account)이 하나의 Smart Contract가 되며, “어떤 요청을 유효하다고 판단할 것인가” 자체를 개발자가 정의할 수 있게 됩니다.

즉, 계정이 단순한 private key의 소유 개념을 넘어:

• 정책을 가질 수 있고
• 복구 기능을 가질 수 있으며
• 여러 서명 방식을 사용할 수 있고
• 서비스 목적에 맞는 UX를 직접 구현할 수 있는

하나의 programmable entity가 됩니다.

그리고 ERC-4337은 이러한 구조를 consensus layer 변경 없이 Ethereum 위에서 구현하기 위한 현실적인 접근입니다.

결국 Account Abstraction은 단순한 기능 추가가 아니라,

“Ethereum 계정 모델 자체를 소프트웨어적으로 확장 가능하게 만든 변화”

라고 볼 수 있겠습니다.

컨트랙트의 상태가 업데이트 되기 전, 함수를 다시 호출(재진입)하여 공격하는 기법

다음과 같은 기능을 갖고있는 컨트랙트는 reentrancy attack 에 취약합니다.

• 외부 컨트랙트의 함수를 호출
• 외부 컨트랙트로 native token 을 전송
• 자산 전송 이후에 상태업데이트

다음은 Reentrancy 에 취약한 컨트랙트와 이를 공격하는 컨트랙트 코드 예시입니다.

contract vulnerableContract{
    mapping(address => uint256) public balances;

    function withdraw() public{
        require(balances[msg.sender] > 0);

        (bool success, ) = msg.sender.call{value: balances[msg.sender]}("");
        require(success);

        balances[msg.sender] = 0;
    }
}

contract maliciousContract{
    IVulnerableContract public vCa = "0xsomeAddress..";

    function exploit() external {
        vCa.withdraw();
    }

    fallback() external payable {
        if(address(vCa).balance >= vCa.balances(address(this))){
            vCa.withdraw();
        }
    }
}

위의 두 컨트랙트는 다음과 같은 흐름으로 exploit이 됩니다.

대응법

1. 자산 전송 전 상태업데이트 먼저 하기

contract safeContract{
    mapping(address => uint256) public balances;

    function withdraw() public{
        require(balances[msg.sender] > 0);

        uint256 transferAmount = balnaces[msg.sender];
        balances[msg.sender] = 0;

        (bool success, ) = msg.sender.call{value: transferAmount}("");
        require(success);
    }
}

상태(msg.sender 의 balance) 업데이트 → 자산 전송 의 순서로 코드가 실행되면 재진입을 하더라도 잔액을 확인하는 부분에서 오류가 발생하기 때문에 재진입 공격에 실패하게 됩니다.

2. Mutex 사용

contract safeContract{
    mapping(address => uint256) public balances;
    bool mutex = false;

    function withdraw() public{
        require(!mutex, "Mutex is locked");
        require(balances[msg.sender] > 0, "Insufficient balance");

        mutex = true;

        (bool success, ) = msg.sender.call{value: balances[msg.sender]}("");
        require(success, "tx is failed");

        balances[msg.sender] = 0;

        mutex = false;
    }
}

재진입을 하더라도 mutex가 잠겨있는 상태이기 때문에 tx가 실패하게 됩니다.

3. Openzeppelin ReentrancyGuard 사용

import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract safeContract {
    mapping(address => uint256) public balances;

    function withdraw() public nonReentrant{
        require(balances[msg.sender] > 0, "Insufficient balance");

        (bool success, ) = msg.sender.call{value: balances[msg.sender]}("");
        require(success, "tx is failed");

        balances[msg.sender] = 0;
    }
}

mutex와 동일한 원리입니다. openzeppelin 에서 표준화한 코드를 사용합니다.

여느때와 같이 당근을 보던 중

신품기준 무려 약 29만원짜리 상품을 단돈 13만원에 판매한다는 글을 보았고, 바로 메세지를 보냈습니다.

오케이 굿. 바로 구매 ㄱㄱ

연락을 한 다음 날 바~~로 집으로 데려왔습니다.

케이스는 군시절이 떠오르는 국방색이고 사이즈는 수첩? 정도의 아주 작고 귀여운 미니PC 입니다.

이 친구를 처음 데려왔을 때에는 윈도우11 이 설치되어 있었습니다.

저는 개발자기 때문에(?) 바로 우분투를 깔기로 마음먹었습니다.

또한, 그냥 개발자가 아닌 "BackEnd Developer" 이기 때문에, GUI 따위 필요없다 선언하고 바~로 Ubuntu Server 를 설치했습니다.

화면에 딱 한줄 띄워져 있는 모습, 아주 멋있지 않나요?

그런데, 막상 설치하고 나니 무인도에 알몸으로 던져진 느낌이었습니다.

인터넷 조차 직접 설정해야 되더라구요.. 새삼 GUI의 편리함을 느끼게 되는 계기였습니다.

패기롭게 시작하였지만 아는게 없는 저는 바~로 GPT선생님께 질문하였고 역시나 갓갓갓선생님께서는 설정법을 아주 쉽게 알려주셨습니다.

먼저 ip a 명령어를 입력해서 사용할 수 있는 랜카드를 확인합니다.

확인 결과, 유선랜포트는 enp3s0 라고 라고 돼있었습니다.

인터넷에 연결하기 위해 /etc/netplan/00-wired.yaml 파일을 생성해주고 다음 내용을 작성했습니다.

network:
  version: 2
  renderer: networkd
  ethernets:
    enp3s0:
      dhcp4: true

그 다음 ~$ sudo netplan apply 로 설정파일 적용!

~$ ping 8.8.8.8 명령어를 통해 인터넷 연결이 잘 되었는지 (google dns 서버와 통신이 되는지) 확인을 하고

ssh를 설치했습니다

apt install -y openssh-server systemctl enable ssh systemctl start ssh

짜라란~ 접속 성공!

자, 그럼 이제 무엇을 해볼지 고민을 해야합니다.

https://github.com/natreeum/HybridIndexer

개요

기존 인덱싱 방식은 http 방식(Polling)으로 진행. 이로인해 설정된 주기로만 요청하므로 최대 ‘설정된 주기까지의 delay’가 생김. 이로 인해 낙관적 업데이트와 같은 추가 작업을 필요로 합니다.

구상

1. ws provider를 통한 event subscription으로 event 발생 시 트랜잭션(event) 수집
2. 웹소켓으로 수집된 트랜잭션은 DB에 저장 a. 최초 status 는 unconfirmed상태로 저장
3. batch indexing을 통해 unconfirmed 상태의 트랜잭션에 대해 confirm a. removed : true 인 경우(reorg) 삭제 b. 누락된 데이터 업데이트
4. ws connection 이 유실되었을 경우 재연결 시도

0. Contract

Event 를 emit 하는 단순한 컨트랙트 배포

code : Test.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Test {
    event LogMessage(string message);
    event TestTransfer(address indexed from, address indexed to, uint256 value);

    function emitLogMessage(string memory message) public {
        emit LogMessage(message);
    }

    function transfer(address to, uint256 value) public {
        emit TestTransfer(msg.sender, to, value);
    }
}

1. Websocket으로 Emit되는 event 확인

code : indexer.js

const { ethers } = require("ethers");
module.exports = class HybridIndexer {
  constructor({
    wsUrl,
    httpUrl,
    contractCfg, // {address, abi}
    events, // ["Transfer", ...]
    confirmations = 10,
    chunkSize = 2000,
    poolIntervalMs = 5000,
  }) {
    this.wsUrl = wsUrl;
    this.httpUrl = httpUrl;
    this.contractCfg = contractCfg;
    this.events = events;
    this.confirmations = confirmations;
    this.chunkSize = chunkSize;
    this.poolIntervalMs = poolIntervalMs;

    this.wsProvider = null;
    this.httpProvider = null;
    this.wsContract = null;
    this.httpContract = null;
    this.running = false;
  }

  async start() {
    this.running = true;

    this.wsProvider = new ethers.WebSocketProvider(this.wsUrl);
    this.httpProvider = new ethers.JsonRpcProvider(this.httpUrl);

    this.wsContract = new ethers.Contract(
      this.contractCfg.address,
      this.contractCfg.abi,
      this.wsProvider
    );
    console.log(`WebSocket Provider connected to ${this.wsUrl}`);

    this.httpContract = new ethers.Contract(
      this.contractCfg.address,
      this.contractCfg.abi,
      this.httpProvider
    );
    console.log(`HTTP Provider connected to ${this.httpUrl}`);

    this._subscribeEvents();
    console.log("HybridIndexer started");
  }

  _subscribeEvents() {
    this.events.forEach((eventName) => {
      this.wsContract.on(eventName, async (...args) => {
        console.log(args);
      });
    });
  }
};

code : server.js

const express = require("express");
const Indexer = require("./indexer/hybridIndexer");

const app = express();

// Fuji Network configuration
const wsUrl = "wss://api.avax-test.network/ext/bc/C/ws";
const httpUrl = "https://api.avax-test.network/ext/bc/C/rpc";
const abi = require("./abi/ABI.json"); // 예시 ABI 파일
const contractAddress = "0xa85761417ed8ae28378612a63282b4A576949377";
const contractCfg = {address : contractAddress, abi}
const events = ["LogMessage","TestTransfer"]

app.get("/", (req, res) => {
  return res.send("Hello, World!");
});

const indexer = new Indexer({
  wsUrl,
  httpUrl,
  contractCfg, // ethers.Contract Instance
  events, // ["Transfer", ...]
});


indexer.start()

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

서버를 실행하면 indexer가 실행되고, events에 대해 subscription 실행

Test.sol 의 LogMessage Event 발생 시 서버측에서 이벤트 확인

2. DB Table

확장성을 고려해서 공통 column / eventArgs column을 구분

공통 column

• transaction_hash
• block_number
• log_index
• transaction_index
• confirmed

Event Args Column

• ...

3. Indexer Constructor

• wsUrl : WebSocket RPC URL
• httpUrl : http RPC URL
• contractCfg
  • address : 컨트랙트 주소
  • abi : 컨트랙트 abi
• eventName : 받아올 event의 이름
• tableName : 받아온 event data 를 저장하는 table 이름
• argKeys : args 이름 배열 [”eventArgName1”, “eventArgName2”]
• confirmations : block confirmation 수
• chunkSize : polling 최대 블록 수
• pollIntervalMs : polling 인터벌 ms
• pingIntervalMs : ws connection status 체크를 위한 ping 인터벌 ms

구현

Hybrid Indexer

const { ethers } = require("ethers");
const log = require("../libraries/timestampLog");
const insertEvent = require("../database/insert");
const updateEvent = require("../database/update");
const deleteEvent = require("../database/delete");
const updateLastQueryBlockNumber = require("../database/updateLastQueryBlock");
const getLastBlockNumber = require("../database/getLastBlockNumber");
const getEvent = require("../database/getEvent");

module.exports = class HybridIndexer {
  constructor({
    wsUrl,
    httpUrl,
    contractCfg, // {address, abi}
    eventName,
    tableName,
    argKeys, // ["eventArgName1", "eventArgName2"]
    confirmations = 10,
    chunkSize = 1000,
    pollIntervalMs = 30000, // Default 30 seconds
    pingIntervalMs = 300000, // Default 5 minutes
  }) {
    this.wsUrl = wsUrl;
    this.httpUrl = httpUrl;
    this.contractCfg = contractCfg;
    this.eventName = eventName;
    this.confirmations = confirmations;
    this.chunkSize = chunkSize;
    this.pollIntervalMs = pollIntervalMs;
    this.intervalPoll = null;
    this.mutexLock = false;
    this.lastConfirmedBlock = 0;

    this.wsProvider = null;
    this.httpProvider = null;
    this.wsContract = null;
    this.httpContract = null;

    this.tableName = tableName;
    this.argKeys = argKeys;

    this.intervalPing = null;
    this.pingIntervalMs = pingIntervalMs;

    this.running = false;
  }

  async start() {
    this.running = true;

    this.wsProvider = new ethers.WebSocketProvider(this.wsUrl);
    this.httpProvider = new ethers.JsonRpcProvider(this.httpUrl);

    this.wsContract = new ethers.Contract(
      this.contractCfg.address,
      this.contractCfg.abi,
      this.wsProvider
    );
    log(`WebSocket Provider is set to ${this.wsUrl}`);
    this.wsProvider.websocket.on("open", () => {
      log(`WebSocket connected to ${this.wsUrl}`);
    });

    this.httpContract = new ethers.Contract(
      this.contractCfg.address,
      this.contractCfg.abi,
      this.httpProvider
    );
    log(`HTTP Provider is set to ${this.httpUrl}`);

    this._subscribeEvents();
    log("HybridIndexer started");

    // reconnect on error
    this.wsProvider.websocket.on("error", () => {
      log(`WebSocket Error Occurred`);
      this.wsProvider?.removeAllListeners?.();
      log(`Removing all listeners from WebSocket Provider`);
      this.wsProvider?.destroy?.();
      log(`WebSocket Provider destroyed`);

      if (this.running) {
        log("Attempting to reconnect...");
        this.start();
      }
    });

    // reconnect on close
    this.wsProvider.websocket.on("close", () => {
      log(`WebSocket Connection Closed`);
      this.wsProvider?.removeAllListeners?.();
      log(`Removing all listeners from WebSocket Provider`);
      this.wsProvider?.destroy?.();
      log(`WebSocket Provider destroyed`);

      // Reconnect if still running
      if (this.running) {
        log("Attempting to reconnect...");
        this.start();
      }
    });

    // To keep the WebSocket connection alive, send periodic pings
    this.intervalPing = setInterval(() => {
      if (this.wsProvider.websocket.readyState === 1) {
        this.wsProvider.websocket.ping();
        log("WebSocket ping sent");
      } else {
        log("WebSocket is not open, skipping ping");
      }
    }, this.pingIntervalMs);

    this._confirmEvents();
  }

  stop() {
    this.running = false;
    try {
      this.wsProvider?.removeAllListeners?.();
      this.wsProvider?.destroy?.();
      this.wsProvider = null;
    } catch (error) {
      error("Error stopping WebSocket Provider:", error);
    }

    // Clear the ping interval if it exists
    if (this.intervalPing) {
      clearInterval(this.intervalPing);
      this.intervalPing = null;
      log("Ping interval cleared");
    }

    log("HybridIndexer stopped");
  }

  _subscribeEvents() {
    this.wsContract.on(this.eventName, async (...args) => {
      const event = args[args.length - 1]; // ethers v6: 마지막 인자가 Event

      await insertEvent({
        tableName: this.tableName,
        transactionHash: event.log.transactionHash,
        blockNumber: event.log.blockNumber,
        logIndex: event.log.index,
        transactionIndex: event.log.transactionIndex,
        argKeys: this.argKeys,
        argValues: event.log.args,
      });
      log(
        `Event has been inserted into the database : ${event.log.blockNumber}-${event.log.index}-${event.log.transactionIndex}`
      );
    });
    log(`Subscribed to event: ${this.eventName}`);
  }

  _confirmEvents() {
    this.intervalPoll = setInterval(async () => {
      if (this.mutexLock) {
        console.log(`Mutex is locked`);
        return;
      }
      this.mutexLock = true;
      try {
        const network = await this.httpProvider.getNetwork();
        const lastBlockNumber = await getLastBlockNumber({
          eventName: this.eventName,
          contractAddress: this.contractCfg.address,
          networkId: network.chainId.toString(),
        });
        console.log("last block number : ", lastBlockNumber);
        const currentBlockNumber = await this.httpProvider.getBlockNumber();
        console.log("Current block number : ", currentBlockNumber);
        const filter = this.httpContract.filters[this.eventName]();

        const fromBlockNumber = lastBlockNumber + 1;
        const toBlockNumber = Math.min(
          currentBlockNumber - this.confirmations,
          fromBlockNumber + this.chunkSize
        );
        console.log(fromBlockNumber);
        console.log(toBlockNumber);

        // invalid block range
        if (fromBlockNumber >= toBlockNumber) {
          console.log(
            `Block range is invalid: from:${fromBlockNumber} >= to:${toBlockNumber}`
          );
          throw new Error(`Invalid block range`);
        }

        const events = await this.httpContract.queryFilter(
          filter,
          fromBlockNumber,
          toBlockNumber
        );

        for (const e of events) {
          const {
            transactionHash,
            blockNumber,
            removed,
            index,
            transactionIndex,
            args,
          } = e;
          // Check if this event exist on db
          const exists = await getEvent({
            tableName: this.tableName,
            transactionHash,
            blockNumber,
            index,
            transactionIndex,
          });
          if (exists.length > 0) {
            if (!removed) {
              // if the event is not removed, update "confirmed" as 1
              await updateEvent({
                tableName: this.tableName,
                transactionHash,
                blockNumber,
                index,
                transactionIndex,
              });
            } else {
              // if the event is removed, delete the row
              await deleteEvent({
                tableName: this.tableName,
                transactionHash,
                blockNumber,
                index,
                transactionIndex,
              });
            }
          } else {
            // if the event is not exist on db, insert it
            await insertEvent({
              tableName: this.tableName,
              transactionHash,
              blockNumber,
              logIndex: index,
              transactionIndex,
              argKeys: this.argKeys,
              argValues: args,
            });
          }
        }
        console.log(`${events.length} events processed`);
        await updateLastQueryBlockNumber({
          tableName: "event_query_info",
          eventName: this.eventName,
          contractAddress: this.contractCfg.address,
          networkId: network.chainId.toString(),
          lastQueryBlockNumber: toBlockNumber,
        });
      } catch (e) {
        console.log(e);
      } finally {
        this.mutexLock = false;
      }
    }, this.pollIntervalMs);
  }

  websocketStatus() {
    return this.wsProvider?.websocket?.readyState === 1
      ? "Connected"
      : "Disconnected";
  }
};

서버 실행

Event 발생 시 즉시 DB에 row 생성

새로운 row 확인

새로운 row가 insert된 내용의 log

Polling 으로 Tx Confirm

confirmed status 가 0->1 로 변경됨

server - confirmed event log

Websocket Ping 으로 health check

Polling 할 block range 를 기록하기 위한 테이블

Uniswap Multicall 컨트랙트의 코드를 살펴보면 다음과 같습니다.

Call 이라는 data struct를 배열로 받고, target.call() 을 통해 배열로 전달된 callData 를 target contract에 실행시킵니다.

여기서 해당 tx의 실행 주체는 uniswap multicall contract가 됩니다.

이를 악용한 공격 수법을 알아보겠습니다.

공격자는 피해자에게 다음과 같은 Approve 트랜잭션에 서명하도록 합니다.

• Spender : Uniswap Multicall Contract
• Amount : uint256 최대치

피해자의 입장에서는 수많은 트랜잭션이 일어나고, 유명한 Uniswap 컨트랙트가 spender 이므로 별다른 의심없이 해당 트랜잭션에 서명하게 됩니다.

이 과정에서 Uniswap Contract는 피해자의 지갑이 보유하고 있는 토큰에 대한 제어권을 갖게 됩니다.

Uniswap Contract가 피해자의 토큰에 대한 제어권을 갖게 되면, 공격자는 Uniswap Contract에 대해 transferFrom 메소드를 다음과같이 호출합니다.

• sender : 피해자 지갑주소
• recipient : 공격자 지갑 주소
• amount : 수량

여기서 transferFrom 은 다음과 같이 작동합니다. transferFrom(sender, recipient, amount); tx를 전송하는 주체(msg.sender)는 sender로 부터 allowance 를 취득해야하고, allowance가 충분할 경우 sender의 지갑에서 recipient에게 amount만큼 전송합니다.

이 과정을 도식화 하면 다음과 같습니다.

Gnosis Safe

비슷한 사례로 Gnosis safe wallet (multi sig wallet)을 통한 공격도 있었습니다.

공격의 순서는 다음과 같습니다

1. 공격자는 safe wallet(proxy)을 생성합니다
2. 공격자는 피해자에게 safe wallet에 대한 approve를 서명하도록 유도합니다.
3. 피해자가 approve tx에 서명을 하면, 공격자는 proxy 컨트랙트의 execTransaction 메소드를 호출
4. proxy 컨트랙트는 마스터 컨트랙트의 execTransaction을 delegateCall을 통해 호출

이 과정을 도식화 하면 다음과 같습니다.

개발 시 주의할 점

• 공개된 multicall contract 에 approve 를 수행해서는 절대 안됨
• multicall 기능이 필요하다면, tx를 대신해서 수행하는 메소드에 권한을 추가하여(whitelisted) 제한적으로 사용

참고 : https://research.checkpoint.com/2024/unveiling-the-scam-how-fraudsters-abuse-legitimate-blockchain-protocols-to-steal-your-cryptocurrency-wallet/

EIP-712

EIP-712 는 트랜젝션 데이터가 아닌 모든 데이터를 어떤 구조로 서명할 지에 대해 정의한 제안이며 사용자에게 서명할 메세지를 사람이 읽을 수 있는 구조로 보여주고, 그 구조에 따라 서명하여 신뢰성과 보안성을 높이는데 초점을 둡니다.

핵심 요소

TYPE_HASH

TYPE_HASH 는 기능이름(parameters) 로 된 문자열을 keccak256 으로 해싱 한 값입니다.

EIP712Domain 에 대한 TYPE_HASH 는 다음과 같습니다.

keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

domainSeperator

어떤 네트워크의 어떤 컨트랙트에서 사용되는(검증되는) 서명인지 구분하기 위한 구분자.

DomainSeperator 의 구성은 다음과 같습니다.

• string name : 컨트랙트(DApp 혹은 Protocol)의 이름
• string version : 컨트랙트 버전
• uint256 chainId : 컨트랙트가 배포된 네트워크 아이디
• address verifyingContract : 서명을 검증하는 컨트랙트의 주소(배포된 컨트랙트 주소)

Openzeppelin 에서 DomainSeperator를 생성하는 코드는 다음과 같습니다. (EIP712.sol#L90)

function _buildDomainSeparator() private view returns (bytes32) {
    return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
}

encodeType

Parameter 로 전달되는 인자의 type을 정의한 정의서. encodeType을 통해 해당 함수에 대한 TYPE_HASH 가 생성됩니다.

예시

const type = {
    transfer: [
      {name:"to", type:"address"},
      {name:"amount", type:"uint256"},
    ]
};

encodeData

Parameter 로 전달되는 인자의 값

예시

const data = {
    to : wallet.address,
      amount : 1000000000000000000n
};

검증 과정

1. signer는 private key 를 사용하여 메세지를 서명합니다. 서명된 메세지는 다음 데이터들로부터 생성됩니다.

   • domainSeperator
   • encodeType
   • encodeData

2. 서명된 메세지(signature)는 v, r, s 로 분리됩니다.

   • v, r, s 는 ECDSA(타원곡선을 이용한 전자서명알고리즘)을 위한 값

3. 함수 호출자는 서명된 데이터(v,r,s) 와 arguments 를 함께 전달합니다.

4. 함수에서는 전달받는 arguments 와 v,r,s 값으로 ecrecover 함수를 통해 해당 서명을 검증합니다.

   a. 서명에 사용된 값과 arguments 값이 일치하면 ecrecover 는 서명자의 주소를 반환합니다.

   b. 서명에 사용된 값과 arguments 값이 일치하지 않을경우 ecrecover 는 엉뚱한 주소를 반환합니다.

예시
1. owner 가 to:0x1234, amount:100 값에 대해 서명하여 Signature 생성
2. 함수호출자가 to:0x1234, amount:9000000 라는 값을 Owner 의 Signature 와 함께 호출
-> 검증 과정에서 ecrecover 가 엉뚱한 주소를 반환하여 검증 실패

1. owner 가 to:0x1234, amount:100 값에 대해 서명하여 Signature 생성
2. 함수호출자가 to:0x1234, amount:100 라는 값을 Owner 의 Signature 와 함께 호출
-> 검증 과정에서 ecrecover 가 owner의 주소를 반환하여 검증 성공

컨트랙트 코드를 함께 보며 이해도를 높이면 좋을것 같습니다. 다음은 설명을 위한 컨트랙트의 함수 코드입니다.

// mintWithApproval() 은 owner의 private key 로 sign 된 메세지(signature)가 정상일 때 민팅을 할 수 있는 함수입니다.
function mintWithApproval(
    address to,
    uint256 amount,
    uint8 v,
    bytes32 r,
    bytes32 s
) external {
    // 함수의 TYPE_HASH 와 전달받은 arguments 로 structHash 를 생성합니다.
    bytes32 structHash = keccak256(
        abi.encode(
            keccak256("mintWithApproval(address to,uint256 amount)"), // TYPE_HASH
            to, // arg1
            amount // arg2
        )
    );

    bytes32 hash = _hashTypedDataV4(structHash);

    // 서명된 데이터(v,r,s) 에 사용된 데이터와 arguments(to, amount) 값이 같다면 ecrecover 는 서명한 지갑의 주소를 반환합니다.
    address signer = ecrecover(hash, v, r, s);


    if (signer != owner) {
        revert("Invalid signature");
    }

    _mint(to, amount);
}

EIP-712 를 따르는 서명 생성하기

EIP-712 를 따르는 서명을 만드는 방법은 다양하겠지만 이 글에서는 ehters.js 라이브러리로 서명을 생성하는 방법만 다뤄보겠습니다.

ethers.js

도메인 지정

domainSeperator 생성을 위한 도메인을 지정해줍니다.

const domain = {
    name: "Test",
      version: "1",
      chainId: 1,
      verifyingContract: "0x1234contractAddress"
};

Type 지정

parameter 로 전달할 인자들의 타입을 지정해줍니다.

const types = {
    mintWithApproval:[
      {name: "to", type: "address"},
      {name: "amount", type: "uint256"},
    ]
};

Data 지정

parameter 로 전달할 인자들의 값을 지정해줍니다.

const data = {
    to: "0x9876walletAddress",
      amount: 1000000000000000000n
};

Signature 생성 + vrs 로 분리

ethers 의 Wallet instance 로 서명을 생성합니다.

const owner = ethers.Wallet.createRandom();

const signature = owner.signTypedData(domain, types, data);

const {v, r, s} = ethers.Signature.from(signature);

HashMap : key - value

key와 value 는 어떤 타입도 될 수 있음

(key)String -> (value)Vec<String> 의 hashMap 을 만들고 싶다면 다음과 같이 사용

// HashMap<String, Vec<String>>

hashMap example

use std::collections::HashMap;

struct City{
    name: String,
    population: HashMap<u32, u32> // year -> population
}

fn main(){
    let mut tallin = City {
        name : "Tallin".to_string(),
        population: HashMap::new()
    };

    tallin.population.insert(1372, 3_250);
    tallin.population.insert(1851, 24_000);
    tallin.population.insert(2020, 437_619);

    for(year, population) in tallin.population{
        println!("In the year {} the population was {}", year, population)
    }
}

1372년, 1851년, 2020년의 순서로 나오지 않음. (순서는 완전 랜덤)

hashMap 은 순서를 정의할 수 없는 특징이 있음.

BTreeMap : ordering 이 가능한 HashMap

order가 필요없다면 HashMap, 필요하다면 BTreeMap(상대적으로 느림)

BTreeMap 예시

use std::collections::BTreeMap;

struct City{
    name: String,
    population: BTreeMap<u32, u32> // year -> population
}

fn main(){
    let mut tallin = City {
        name : "Tallin".to_string(),
        population: BTreeMap::new()
    };

    tallin.population.insert(1372, 3_250);
    tallin.population.insert(1851, 24_000);
    tallin.population.insert(2020, 437_619);

    for(year, population) in tallin.population{
        println!("In the year {} the population was {}", year, population)
    }
}
// 1372년 -> 1851년 -> 2020년 순서가 보장됨

052

HashMap 의 값을 불러오는 방법

(안전x 방법)

use std::collections::HashMap;

fn main(){
    let canadian_cities = vec!["Calgary", "Vancouver", "Gimli"];
    let german_cities = vec!["Karlsruhe", "Bad Doberan", "Bielefeld"];

    let mut city_hashmap = HashMap::new();

    for city in canadian_cities{
        city_hashmap.insert(city, "Canada");
    }

    for city in german_cities{
        city_hashmap.insert(city, "Germany");
    }

    println!("{:?}", city_hashmap["Bielefeld"]); // 정상 출력 (Bielefeld 라는 key가 존재함)

    println!("{:?}", city_hashmap["Bielefeld123"]); // key 가 존재하지 않아서 오류 발생 
}

(안전한 방법, .get 사용) .get을 사용하면 "None"을 반환

use std::collections::HashMap;

fn main(){
    let canadian_cities = vec!["Calgary", "Vancouver", "Gimli"];
    let german_cities = vec!["Karlsruhe", "Bad Doberan", "Bielefeld"];

    let mut city_hashmap = HashMap::new();

    for city in canadian_cities{
        city_hashmap.insert(city, "Canada");
    }

    for city in german_cities{
        city_hashmap.insert(city, "Germany");
    }

    println!("{:?}", city_hashmap.get("Bielefeld")); // Some("Germany") 출력

    println!("{:?}", city_hashmap.get("Bielefeld123")); // None 출력
}

이미 값이 존재하는 key 에 대해 insert하게 되면 덮어쓰기가 됨.

use std::collections::HashMap;

fn main(){
    let mut book_hashmap = HashMap::new();

    book_hashmap.insert(1, "Book1");
    book_hashmap.insert(1, "Book2");
    book_hashmap.insert(1, "Book3");
    book_hashmap.insert(1, "Book4");

    println!("{:?}", book_hashmap.get(&1)); // hashmap 에게 소유권을 넘기지 않고 reference 만 제공하기 위해 &1 사용
}

is_none 활용

use std::collections::HashMap;

fn main(){
    let mut book_hashmap = HashMap::new();

    book_hashmap.insert(1, "Book1");

    if book_hashmap.get(&1).is_none() {
        book_hashmap.insert(1, "Book1");
    } else {
        println!("Already got a book");
    }
}

• if let 활용

use std::collections::HashMap;

fn main(){
    let mut book_hashmap = HashMap::new();

    book_hashmap.insert(1, "Book1");

    if let Some(book_name) = book_hashmap.get(&1) {
        println!("Already got a book : {}", book_name);
    } else {
        book_hashmap.insert(1, "Book1");
    }
}

053

Entry Method

use std::collections::HashMap;

fn main(){
    let book_collection = vec![
        "book1",
        "book2",
        "book3",
        "book4",
        "book4",
    ];

    let mut book_hashmap = HashMap::new();

    for book in book_collection{
        book_hashmap.entry(book).or_insert(true);
    }

    for (book, true_or_false) in book_hashmap{
        println!("Do we have {}? : {}", book, true_or_false);
    }
}

.entry() method

pub fn entry(&mut self, key: K) -> Entry<K, V>

pub enum Entry<'a, K: 'a, V: 'a> {
    Occupied(OccupiedEntry<'a, K, V>),
    Vacant(VacantEntry<'a, K, V>),
}

Entry.or_insert() 는 &'a mut 을 반환하기 때문에 값을 바꿀 수 있음

use std::collections::HashMap;

fn main(){
    let book_collection = vec![
        "book1",
        "book2",
        "book3",
        "book4",
        "book4",
    ];

    let mut book_hashmap = HashMap::new();

    for book in book_collection{
        let number_of_books = book_hashmap.entry(book).or_insert(0); // number_of_books -> &ref
        *number_of_books += 1;
    }

    for (book, number) in book_hashmap{
        println!("{}: {}copies", book, number);
    }
}

054

use std::collections::HashMap;

fn main(){
    let data = vec![
        ("male", 9),
        ("female", 5),
        ("male", 0),
        ("female", 6),
        ("female", 5),
        ("male", 10),
    ];

    let mut survey_hash = HashMap::new();

    for item in data { // (&str, i32)
        survey_hash.entry(item.0).or_insert(Vec::new()).push(item.1);
    }

    for (male_or_female, numbers) in survey_hash{
        println!("{:?}, {:?}", male_or_female, numbers)
    }
}

HashSet

use std::collections::HashSet;

fn main(){
    let many_numbers = vec![1,3,5,7,7,9];

    let mut number_hashset = HashSet::new();

    for number in many_numbers {
        number_hashset.insert(number);
    }

    let hashset_length = number_hashset.len(); // hashset length
    println!("There are {} unique numbers, so we are missing {}", hashset_length, 10-hashset_length);

    let mut missing_vec = vec![];
    for number in 0..10{
        if number_hashset.get(&number).is_none() {
            missing_vec.push(number);
        }
    }

    print!("Missing numbers : ");
    for number in missing_vec{
        print!("{} ", number);
    }
}

Set 에서도 Map과 동일하게 순서가 중요하다면 BTreeSet 사용!

055

binaryHeap : 아직 실제로 써본적은 없다고 함

use std::collections::BinaryHeap;

fn show_remainder(input: &BinaryHeap<i32>) -> Vec<i32> {
    let mut remainder_vec = vec![];
    for number in input {
        remainder_vec.push(*number)
    }
    remainder_vec
}

fn main(){
    let many_numbers = vec![0, 5, 10, 15, 20, 25, 30];

    let mut my_heap = BinaryHeap::new();

    for number in many_numbers{
        my_heap.push(number);
    }

    while let Some(number) = my_heap.pop(){
        println!("Popped off {}. Remaining numbers are : {:?}", number, show_remainder(&my_heap));
    }
}
/* Output
Popped off 30. Remaining numbers are : [25, 15, 20, 0, 10, 5]
Popped off 25. Remaining numbers are : [20, 15, 5, 0, 10]
Popped off 20. Remaining numbers are : [15, 10, 5, 0]
Popped off 15. Remaining numbers are : [10, 0, 5]
Popped off 10. Remaining numbers are : [5, 0]
Popped off 5. Remaining numbers are : [0]
Popped off 0. Remaining numbers are : []
*/

-> 첫 번째 요소는 가장 큰 값, 나머지 요소들의 순서는 일관되지 않음

Most popular Usage : Priority Queue

예시 2

use std::collections::BinaryHeap;

fn main(){
    let mut jobs = BinaryHeap::new();

    jobs.push((100, "Write back to email from the CEO"));
    jobs.push((80, "보고서 마감"));
    jobs.push((5, "Youtube 시청"));
    jobs.push((70, "동료들에게 감사인사 전하기"));
    jobs.push((30, "다음 고용계획 작성"));

    while let Some(job) = jobs.pop(){
        println!("You need to: {}", job.1);
    }
}

056

VecDeque

Vec의 경우

fn main(){
    let my_vec = vec![8,9,10];
}

.pop : 맨 마지막값을 뺌 .push : 맨 마지막에 값을 넣음 Vec::with_capacity(10) : reallocation 없이 빠르게 사용

.remove(idx) : idx 의 값을 빼고 나머지 값들의 idx 를 한자리씩 앞으로 이동시킴

다음 상황에서 연산량이 많아서 오래걸리는 처리를 VecDeque 를 사용해서 빠르게 처리할 수 있음

// 오래 걸리는 코드
fn main(){
    let mut my_vec = vec![0; 600_000]; // 0이 60만개있는 vec
    for i in 0..600_000 {
        my_vec.remove(0);
    }
}

// VecDeque 사용
use std::collections::VecDeque;

fn main(){
    let mut my_vec = VecDeque::from(vec![0; 600_000]);
    for i in 0..600_000{
        my_vec.pop_front();
    }
}

Ring buffer 를 이용해서...........빠름

057

?

use std::num::ParseIntError "8" 같은 값을 int로 변환, "8eo"같은 값은 에러 반환

use std::num::ParseIntError;

fn parse_str(input:&str) -> Result<i32, ParseIntError>{
    let parsed_number = input.parse::<i32>()?; // 성공하면 넘어감 실패하면 return error
    Ok(parsed_number)
}

fn main(){
    for item in vec!["seven", "8", "9.0", "nice","6060"]{
        let parsed = parse_str(item);
        println!("{:?}", parsed);
    }
}

/*
Err(ParseIntError { kind: InvalidDigit })
Ok(8)
Err(ParseIntError { kind: InvalidDigit })
Err(ParseIntError { kind: InvalidDigit })
Ok(6060)
*/

058

https://play.rust-lang.org/ 에서 monaco editor 지원 시작 -> 인텔리센스(자동완성) 가능

format Strings

기존에는 다음과같이 써야만 했다면 println!("Books\n- {:?}\n- {:?}, book1, book2)

업데이트 이후에는 다음과같이 쓸 수 있게 됨 println!("Books\n- {book1:?}\n- {book2:?})

#[derive(Debug)]
struct Book{
    title: String,
    year: u16
}

fn main(){
    let book1 = Book{
        title : "Some title".to_string(),
        year: 1919
    };
    let book2 = Book{
        title : "Book2".to_string(),
        year: 2020
    };

    println!("Books\n{book1:?}\n{book2:?}");

    /* 아직 struct 안의 property 는 지원안함 */
    // println!("My book name : {book1.title});
}

059, 60

traits (다른 언어의 interface와 비슷)

struct Animal {
    name : String
}

trait Canine {
    fn bark(&self){
        println!("Woof Woof!");
    }
    fn run(&self){
        println!("I am running!");
    }
}

impl Canine for Animal{
    // 덮어쓰기 가능
    fn bark(&self){
        println!("멍멍!");
    }
}

fn main(){
    let my_animal = Animal{
        name : "Mr. Mantle".to_string()
    };

    my_animal.bark();
    my_animal.run();

}

match 활용!

fn match_colours(rgb: (u32, u32, u32)){
    match rgb{
        (r, _, _) if r < 10 => println!("Not much red!"),
        (_, g, _) if g < 10 => println!("Not much green!"),
        (_, _, b) if b < 10 => println!("Not much blue!"),
        _ => println!("Every colour has at least 10!")
    }
}

fn main(){
    let first = (200, 0, 0);
    let second = (50, 50, 50);
    let third = (200, 50, 0);

    match_colours(first);
    match_colours(second);
    match_colours(third);
}

다음과 같이 여러 type을 혼용해서 사용할 수 없음

fn main(){
    let my_number = 10;
    let some_var = match my_number {
        10 => 8,
        _ => "Not ten"
    };
}

if 를 사용해도 안되는건 마찬가지

fn main(){
    let my_number = 8;
    let some_var = if my_number == 10 {8} else {
        "something else"
    };
}

return 하는 값의 type을 맞추면 가능!

fn main(){
    let my_number = 10;
    let some_var = if my_number == 10 {"ten"} else {
        "else"
    };
    println!("{}", some_var);
}

다음과 같이도 사용 가능

fn match_number(input: i32){
    match input{
        number @ 0..=10 => println!("It's between 0 and 10. Number : {}", number),
        _ => println!("It's greater than ten")
    }
}

fn main(){
    match_number(10);
    match_number(50);
}

032

Struct! (나중에 비슷한 enum 도 있음)

rust에는 3가지 struct가 있음

// unit struct ( 아무것도 없는 구조체 )
struct FileDirectory;

fn main(){
    let x = FileDirectory;
    println!("The size of struct is {}", std::mem::size_of_val(&x)); // size : 0
}

// tuple struct
struct Colour(u8, u8, u8);

fn main(){
    let my_colour = Colour(20, 50, 100);
    println!("The second colour is {}", my_colour.1); 
}

// named struct : 제일 많이 사용됨
struct Country{
    population: u32,
    capital : String,
    leader_name : String
}

fn main(){
    let canada = Country{
        population : 35_000_000,
        capital: "Ottawa".to_string(),
        leader_name: "Justin Trudeau".to_string()
    };

    println!("The population is {}", canada.population);
}

033

Struct Size

struct Country {
    population: u32,
    capital: String,
    leader_name: String
}

fn main(){
    let population = 35_000_000;
    let capital = "Ottawa".to_string();
    let leader_name = "Justin Trudeau".to_string();

    let my_country = Country {
        population,
        capital,
        leader_name
    };
}

-> js와 비슷한 기능!

use std::mem::size_of_val 을 사용해서 struct의 사이즈를 볼 수 있음

use std::mem::size_of_val;

struct Country {
    population: u32,
    capital: String,
    leader_name: String
}

fn main(){
    let population = 35_000_000;
    let capital = "Ottawa".to_string();
    let leader_name = "Justin Trudeau".to_string();

    let my_country = Country {
        population,
        capital,
        leader_name
    };

    println!("Country is {} bytes in size", size_of_val(&my_country));
}

Alignment

use std::mem::size_of_val;

struct Numbers{
    one: u8,
    two: u8,
    three: u8
}

fn main(){
    let my_numbers = Numbers{
        one : 1,
        two : 2,
        three : 3
    };

    println!("Size of struct : {}", size_of_val(&my_numbers));
} // -> size : 3 (bytes)

use std::mem::size_of_val;

struct Numbers{
    one: u8,
    two: u8,
    three: u8,
    four: u32
}

fn main(){
    let my_numbers = Numbers{
        one : 1,
        two : 2,
        three : 3,
        four: 4
    };

    println!("Size of struct : {}", size_of_val(&my_numbers));
} // -> size : 8 (bytes)

왜 size 가 7 이 아닌 8이냐면 러스트가 바이트수를 맞추기 위해........align하는...부분..

034

ENUM

struct 는 and 의 성격 enum 은 or 의 성격

enum ThingsInTheSky{
    Sun, // compiler 가 보기에 0
    Stars // compiler 가 보기에 1
}

fn create_sky_state(time: i32) -> ThingsInTheSky{
    match time{
        6..=18 => ThingsInTheSky::Sun,
        _ => ThingsInTheSky::Stars
    }
}

fn check_sky_state(state: &ThingsInTheSky){
    match state{
        ThingsInTheSky::Sun => println!("I can see the sun"),
        ThingsInTheSky::Stars => println!("I can see the stars"),
    }
}

fn main(){
    let time = 8;
    let sky_state = create_sky_state(time);

    check_sky_state(&sky_state);
}

035

ENUM2 : 간편하게 사용하기

enum Mood{
    Happy,
    Sleepy,
    NotBad,
    Angry
}

fn match_mood(mood: &Mood) -> i32{
    let happiness_level = match mood {
        Mood::Happy => 10,
        Mood::Sleepy => 6,
        Mood::NotBad => 7,
        Mood::Angry => 2
    };
    happiness_level
}

fn main(){
    let my_mood = Mood::NotBad;
    let happiness_level = match_mood(&my_mood);
    println!("Out of 1 to 10, my happiness is {}", happiness_level);
}

이거를 use를 사용해서 쉽게 쓸 수 있음

enum Mood{
    Happy,
    Sleepy,
    NotBad,
    Angry
}

fn match_mood(mood: &Mood) -> i32{
    use Mood::*;
    let happiness_level = match mood {
        Happy => 10, // Mood:: 안써도 됨 
        Sleepy => 6, // Mood:: 안써도 됨 
        NotBad => 7, // Mood:: 안써도 됨 
        Angry => 2 // Mood:: 안써도 됨 
    };
    happiness_level
}

fn main(){
    let my_mood = Mood::NotBad;
    let happiness_level = match_mood(&my_mood);
    println!("Out of 1 to 10, my happiness is {}", happiness_level);
}

enum의 인덱스(?)를 보려면

enum Season{
    Spring, // 0
    Summer, // 1
    Autumn, // 2
    Winter //3
}

fn main(){
    use Season::*;

    let four_seasons = vec![Spring, Summer, Autumn, Winter]; // Vec<Season>
    for season in four_seasons {
        println!("The number is: {}", season as u32);
    }
}

036

ENUM3

enum Star{
    BrownDwarf = 10,
    RedDwarf = 50,
    YellowStar = 100,
    RedGiant = 1000,
    DeadStar 
}

fn main(){
    use Star::*;

    let starvec = vec![BrownDwarf, RedDwarf, YellowStar, RedGiant, DeadStar];

    for star in starvec{
        match star as u32{
        size if size <= 80 => println!("Not the biggest star: {}", size),
        size if size >= 80 => println!("Pretty big star: {}", size),
        _ => println!("Some other star")
        }
    };

    println!("What about DeadStar? It is: {}", DeadStar as u32); // 제일 마지막 숫자 + 1
}

enum 이 값을 가지게 할수있음

enum Number{
    U32(u32),
    I32(i32)
}

fn get_number(input: i32) -> Number {
    let number = match input.is_positive(){
        true => Number::U32(input as u32),
        false => Number::I32(input)
    };
    number
}

fn main(){
    let my_vec = vec![get_number(-800), get_number(8)];

    for item in my_vec{
        match item {
            Number::U32(number) => println!("It's a u32 with the value : {}", number),
            Number::I32(number) => println!("It's a i32 with the value : {}", number),
        }
    }
}

037

Loops

기본적인 loop

// rust 스럽지 않은 방법!
fn main(){
    let mut counter = 0;
    loop{
        counter += 1;
        println!("The counter is: {}", counter);
        if counter == 5 {
            break;
        }
    }
}

loop에 이름을 지을 수 있음! (tick 이라고 함)

fn main(){
    let mut counter = 0;
    let mut counter2 = 0;

    'first_loop: loop {
        counter += 1;
        println!("The counter is now: {}", counter);
        if counter > 9 {
            println!("Now entering the second loop");

            'second_loop: loop{
                println!("The second counter is: {}", counter2);
                counter2 += 1;
                if counter2 == 3 {
                    break 'first_loop;
                }
            }
        }
    }
}    

038

counter.. 만들어서 하면 rust 적이지 않은 loop!

그럼 어케?

fn main(){
    let mut counter = 0;
    while counter != 5 {
        counter += 1;
        println!("The counter is now: {}", counter);
    }
}

while loop 도 괜찮긴 하지만 제일 많이 사용하는건 for loop

fn main(){
    for number in 0..3 { // 0..3 -> exclusive range!
        println!("The number is {}", number);
    }

    for number in 0..=3 { // 0..3 -> inclusive range!
        println!("The number is {}", number);
    }
}

mutable references and mut in function

fn add_is_great(country_name: &mut String){
    country_name.push_str(" is great!");
    println!("Now it says: {}", country_name);
}

fn main(){
    let mut my_country = "캐나다".to_string();

    /*
    add_is_great(my_country); // by value
    add_is_great(&my_country); // by reference
    */
    add_is_great(&mut my_country); // by mutable reference
    add_is_great(&mut my_country);
}

/* Output
Now it says: 캐나다 is great!
Now it says: 캐나다 is great! is great!
*/

비슷하지만 완전 다른 개념!

fn add_is_great(mut country_name: String){ // take by value, declare as mutable
    country_name.push_str(" is great!");
    println!("Now it says: {}", country_name);
}

fn main(){
    let my_country = "대한민국".to_string();
    add_is_great(my_country); // 여기서 소유권이 넘어감!
}

022

Ownership and copy types

fn prints_number(number: i32){
    println!("{}", number);
}

fn prints_string(input: String){
    println!("{}", input);
}

fn main(){
    let my_number = 8;
    prints_number(my_number); // number 는 copy type(copy 하기 쉬움)이라 소유권 신경쓸 필요 없음!
    prints_number(my_number);

    let my_country = "Austria".to_string();
    prints_string(my_country); // 여기서 소유권 넘어감!
    prints_string(my_country); // 그래서 여기서 오류남!

    /*
        오류가 안나게 하려면 .clone 메서드를 사용
        prints_string(my_country.clone());

        clone은 빠르게 컴파일을 하고싶을 때 많이 사용함!
    */

}

023

uninitialized variable & loop

fn main(){
    /*
    let my_number; // 는 불가능!
    */

    /*
    let my_number: i8; // 는 사용은 가능!

    println!("{}", my_number); // 하지만 여기서 에러남!! value가 initialized 되지 않았기 때문
    */

}

fn loop_then_return(mut counter: i32) -> i32 {
    loop {
        counter += 1;
        if counter % 50 == 0 {
            break;
        }
    }
    counter
}

fn main(){
    let my_number;

    {
        let x = loop_then_return(43);
        my_number = x
    }

    println!("{}", my_number); // my_number가 위에서 initialized 됐기 때문에 오류가 발생하지 않음
}

하지만 이 패턴은 잘 안사용! 기존의 코드(C 등등..)을 사용하던 개발자들의 편의를 위해 rust에서 허용하는 기능!

024

Arrays

fn main(){
    let array = ["one", "two"]; // type -> [&str; 2]
    let array2 = ["one", "two", "Five"]; // type -> [&str; 3]]

    // array 와 array2 는 다른 타입이라 비교 자체가 불가능!!
    // array 는 추가할 수 없고, 삭제할 수 없고.. 
}

fn main(){
    let array = ["one", "two"];

    //type을 보기 위한 꼼수 : 존재하지 않는 method 사용 ㅋㅋ
      array.zxcvzxcvasdfasdfasd(); // >> 여기서 [type]에 대한 method 가 없습니다!  라고 에러를 뱉음
}

indexing 은 다른 언어와 비슷!

fn main(){
    let array = ["one", "two"];

    println!("{}", array[0]); // "one" 출력

    /*
        없는 index 출력하면 오류남 !
    */
}

025

Slices

fn main(){
    let seasons = ["봄", "여름", "가을", "겨울"];
    println!("{:?}", seasons[0..2]); // 에러 발생!! dynamically sized type 이라 사이즈를 알 수 없기 때문에 오류가 발생함
}

fn main(){
    let seasons = ["봄", "여름", "가을", "겨울"];
    println!("{:?}", &seasons[0..2]); // reference 를 사용해서 넘길 수 있음!

    /*
        &seasons[0..=2] // up to and including
        &seasons[..] // all
        &seasons[3..] // from 4th index
        &seasons[..4] // up to 5th index
    */
}

026

"누구나 좋아하는" Vecs

= vector

fn main(){
    let my_string = String::new(); // string 선언!
    let mut my_vec: Vec<String> = Vec::new(); 
}

fn main(){
    let name1 = String::from("Windy); 
    let name2 = String::from("Gomesy");

    let mut my_vec = Vec::new();
    // Vec::from() 도 사용가능
    /*
        vec![] 로 더 쉽게 사용가능!

        예를 들어
        let my_vec = vec![name1, name2];
    */

    my_vec.push(name1);
    my_vec.push(name2);

    println!("My cats are {:?}", my_vec);
}

027

Traits = 초능력

fn main(){
    let my_name = String::from("Dave Macleod"); // from 사용!
    let my_city: String = "Seoul".into(); // into 사용!! "Seoul"은 String이 아닌 &str 인데 String 변수에 맞게 변환!?
}

fn main(){
    let my_vec = Vec::from([8,9,10]); // type : [i32; 3]
}

028

tuples : 여러가지 타입을 한 가지 타입으로 표현하고 싶을 때 사용!

fn main(){
    let my_tuple = (8, "Dave MacLeod", vec![8,9,10]);

    my_tuple.asdfasdfasdf(); // 없는 method 로 컴파일러에게 타입 물어보기 ㅋㅋ 
    // -> no method named `asdfasdfasdf` found for tuple `({integer}, &str, Vec<{integer}>)`
    // type : tuple
}

tuple indexing

/*
    Array 와 Vector 에서 indexing 은 array[0], vec[0] 이런식으로 대괄호를 사용해서 인덱싱
    tuple은 대괄호를 사용하지 않고 .0 .1 이런식으로 사용
*/

fn main(){
    let random_tuple = ("Here is a name", 8, vec!['a'], 'b', [8,9,10], 7.7);

    println!("Inside the tuple");
    println!("0 : {:?}", random_tuple.0);
    println!("1 : {:?}", random_tuple.1);
    println!("2 : {:?}", random_tuple.2);
    println!("3 : {:?}", random_tuple.3);
    println!("4 : {:?}", random_tuple.4);
    println!("5 : {:?}", random_tuple.5);
}

여기서 재밌는 점은, Vector의 경우 같은 type의 요소들만 가질 수 있으나 다음과 같이 여러개의 타입을 묶어서 사용할 수도 있음

fn main(){
    let my_vec = vec![("hey",9), ("Hello there", 123123)];
    println!("{:?}", my_vec)
}

Destructuring! -> js의 분해구조할당과 비슷

fn main(){
    let str_tuple = ("one", "two", "three");

    let (a,b,c) = str_tuple;

    println!("Item 'a' is : {}", a);
}

array 도 똑같이 분해 가능!

fn main(){
    let str_array = ["one", "two", "three"];

    let [a,_,_] = str_array; // 관심없는 b, c 대신 _ 사용 가능 -> 워닝 안뜸

    println!("Item 'a' is : {}", a);
}

029

흐름제어

다른언어에서 if 문을 사용할 때 조건은 () 안에 넣는데 러스트는 괄호를 쓸 필요 없음 (에러는 아님)

fn main(){
    let my_number = 5;
    if my_number == 7 {
        println!("It's seven");
    } else if my_number == 6 {
        println!("It's six");
    } else {
        println!("It's a different number");
    }
}

&& || 도 동일하게 사용 가능

fn main(){
    let my_number = 5;
    if my_number == 5 && my_number == 11 {
        println!("Both are matched");
    } else if my_number == 5 || my_number == 11 {
        println!("my number is 5 or 11");
    } else {
        println!("It's a different number");
    }
}

하지만 이것보다 더 자주 쓰이는건 "match"

-> switch 와 비슷

fn main(){
    let my_number: u8 = 5;

    match my_number{
        0 => println!("It's a zero"),
        1 => println!("It's a one")
    }
} //=>에러남. u8 은 256까지 가능한데 나머지에 대한 정의가 안돼있기 때문 

fn main(){
    let my_number: u8 = 5;

    match my_number{
        0 => println!("It's a zero"),
        1 => println!("It's a one"),
        _ => println!("Other number"); // _ 기호를 사용해서 나머지 타입(else)에 대한 정의
    }
} 

match 로 변수에 값을 할당할 수도 있음

fn main(){
    let my_number: u8 = 5;

    let my_second_number = match my_number{
        0 => 23,
        1 => 34,
        _ => 0
    };

    println!("{}", my_second_number);
} 

030

tuple 활용

여러개의 변수를 한번에 비교할 수도 있음!

fn main(){
    let sky = "cloudy";
    let temperature = "warm";

    match (sky, temperature){
        ("cloudy", "cold") => println!("It's not very nice day"),
        ("cloudy", "warm") => println!("It's a nice day"),
        ("cloudy", _) => println!("Cloudy and something else"),
        _ => println!("Not sure what the weather is")
    }
}

조건문도 사용 가능

fn main(){
    let children = 5;
    let married = true;

    match(children, married){
        (children, married) if married == false => println!("Not married with {} children", children),
        (c,m) if c==0 && m => println!("Married but with no children"),
        _ => println!("Some other type of marriage and children combination")
    }
}

mutability & shadowing

mutability : 변경가능여부

기본적으로 immutable (변수 선언 시 기본적으로 변경 불가능)

fn main(){
    let my_number = 10;
    my_number = 9;
}

>>> ERROR

my_number 는 immutable 이기 때문에 에러 발생 이 경우 mut 키워드를 사용해서 변경가능할 수 있게 해줘야함

fn main(){
    let mut my_number = 10;
    my_number = 9;
}

mut 키워드를 사용하고나서 변경되지 않았다면, 컴파일러가 이를 알려주고, mut 키워드 삭제 가능

shadowing : 같은 이름을 다시 쓰는 것

fn main(){
    let my_variable = 10;
       let my_variable = "My Variable";
}

// -> my_variable 은 마지막에 작성된 "My Variable"만 값으로 생각함.

왜 사용? 코딩을 하면서 필요한 값은 최종 결과인데, 이를 위한 여러 변수들이 불필요하게 선언될 필요 없음

fn double(input: i32) -> i32 {
    input * 2
}

fn triple(input: i32) -> i32 {
    input * 3
}

fn main(){
    let x_origin = 9;
       let x_double = double(x_origin);
    let x_final = triple(x_double);

    println!("{}", x_final);
}

// -> 결과적으로 필요한 값은 xFinal 인데, xOrigin, xDouble 같은 변수가 선언됨

//-----------Shadowing 으로 다음과같이 사용할 수 있음-----------
fn main(){
    let x = 9;
       let x = double(x);
    let x = triple(x);

    println!("{}", x);
}

CodeBlock 을 이용해서 Shadowing을 다양하게 활용할 수 있음

fn main(){
    let my_var = 9;
    {
        let my_var = "Some String";
        println!("{}", my_var); // Some String 출력
    }
    println!("{}", my_var); // 9 출력
}

012

Stack / heap / pointers

Stack Memory

먼저 들어온 Task가 다음에 들어온 Task가 종료될때까지 기다리는 메모리 구조. Task가 종료되면 할당받은 Memory 는 반환

Heap Memory

창고같은 곳에서 "어디로 가면 어떤 물건이 있어요" 같이 동작하는 메모리 구조. 비교적 속도가 느리지만 많은 용량을 저장할 수 있음.

Pointers

아래와 같이 어떤 내용이 어디에 있는지 알려주는 역할

Chapter
Chapter 1: My life, Page : 1 
Chapter 2: My life, Page : 15
Chapter 3: My life, Page : 23 

Rust에서는 Pointer를 Reference 라고 부름. reference 를 사용할 때에는 "&" 기호를 사용함.

fn main(){
    let my_number = 15; // 값. i32
    let single_reference = &my_number; // my_number 에 대한 싱글 레퍼런스. &i32
    let double_reference = &single_reference; // my_number 에 대한 레퍼런스에 대한 레퍼런스. &&i32

    let five_references = &&&&&my_number; // 이것도 사용 가능. 
}

싱글레퍼런스, 더블레퍼런스, 모두 다른 타입이기 때문에 상호 비교가 불가능!!

013

Fancy Printing : print!() 사용

아래 두 줄의 문장은 같은 동작을 함

println!(message); print!("{}\n",message);

예를들면

fn main(){
    //#1
    println!("This");
    println!("is");
    println!("a");
    println!("message");

    //#2
    print!("This\n");
    print!("is\n");
    print!("a\n");
    print!("message\n");

    //#3
    print!("This\nis\na\nmessage\n");
}

위의 1, 2, 3번 코두 동일한 동작을 함

Output : 

This
is
a
message

\n 이라는 기호를 출력하고 싶다면? -> \\n 사용

fn main(){
    print!("This \\n is a message"); // Output : This \n is a message
}

그런데 \를 너무 많이 써야하는 상황이라면? 예를들어 다음 디렉토리를 표시하려면 c:\drive_a\new_drive\path_name

코드는 다음과 같이 안예뻐질 것

fn main(){
    print!("c:\\drive_a\\new_drive\\path_name");
}

이럴때 사용하는것이 "Raw Text" 다음과 같이 사용할 수 있다.

fn main(){
    print!(r#"c:\drive_a\new_drive\path_name"#);
}

줄바꿈을 다음과같이 사용할 수도 있는데

fn main(){
    println!("Let me tell you 
    some story
    about
    rust");
}

출력이 다음과 같다.

Let met tell you
    some story
    about
    rust

앞에 인덴트가 있기 때문에 그런것! 주의하여 사용할 것

전에 Debug Print 에 대해 잠시 다뤘는데

println!("{:?}", var_name);

으로 사용했다.

왜 물음표로 사용하냐면 어떤 타입이든 출력을 하기 때문.

특정 data type을 출력하기 위해선 다음과 같은 format을 사용한다

fn main(){
    let my_number = 9000;
    println!("{:p}", &my_number); // reference(pointer) 출력
    println!("{:X}", my_number); // Hex값 출력
    println!("{:b}", my_number); // Bytes값 출력

    println!("{:p}", my_number); // 는 오류 : p는 포인터 data type을 출력한다고 하는데, my_number 는 값이기 때문에
}

이 포맷을 조금 더 다양하게 활용이 가능하다.

fn main() {
    let title = "TODAY'S NEWS";
    println!("{:-^30}", title); // no variable name, pad with -, put in centre, 30 characters long
    let bar = "|";
    println!("{: <15}{: >15}", bar, bar); // no variable name, pad with space, 15 characters each, one to the left, one to the right
    let a = "SEOUL";
    let b = "TOKYO";
    println!("{city1:-<15}{city2:->15}", city1 = a, city2 = b); // variable names city1 and city2, pad with -, one to the left, one to the right
}

Output:

---------TODAY'S NEWS---------
|                            |
SEOUL--------------------TOKYO

더 많은 내용은 아래 링크 참고 https://doc.rust-lang.org/stable/std/fmt/

014

Strings

String / &str 을 주로 사용

fn main(){
    let my_name = "David"; // &str
    let other_name = String::from("David2");

    /*
    let my_other_name = "David3"; // &str
    my_other_name.push("!"); // 여기서 에러 발생!  &str 에는 .push 가 없기 때문
    */


    // 다음과 같이 하면 오류 발생 안함
    let my_other_name = "David3".to_string(); // String
    my_other_name.push("!");


    println!("{}", my_other_name);
}

String type 은 Sized type str = dynamic type -> 길이를 컴파일러가 알 수 없음 => &str을 사용

015

&str 보다 String 이 사용하기 더 쉬운 이유!

method 사용이 용이함

.push : 한 글자 추가 .push_str : &str 추가 .capacity : 바이트 크기 .pop : with_capacity : 바이트 크기 명시하여 String 선언

let mut my_name = "David".to_string();
my_name.push('!');
println!("My name is {}", my_name);

let mut my_name = String::with_capacity(26);
println!("Length is {} and capacity is {}", my_name.len(), my_name.capacity());
my_name.push_str("David!");
println!("Length is {} and capacity is {}", my_name.len(), my_name.capacity());
my_name.push_str("And I live in Seoul");
println!("Length is {} and capacity is {}", my_name.len(), my_name.capacity());
my_name.push('a');
println!("Length is {} and capacity is {}", my_name.len(), my_name.capacity());

/* Output : 
Length is 0 and capacity is 26
Length is 6 and capacity is 26
Length is 25 and capacity is 26
Length is 26 and capacity is 26
*/

016

const / static

fn main(){
    let x = 8; // 'let' binding 이라고 함
}

const는 Global 변수를 선언함

const NUMBER: i32 = 20; // const 선언 변수명은 대문자로(소문자로 쓰면 warning), 타입 지정은 필수!

fn main(){
    let x = 8; // 'let' binding 이라고 함
}

static도 const와 비슷

const NUMBER: i32 = 20; // const 선언 변수명은 대문자로(소문자로 쓰면 warning), 타입 지정은 필수!
static LOW_SCORE: i32 = 0;

/*
static 은 mut 를 통해 unsafe 를 사용할 수는 있으나 거~~의 안씀!!

static mut LOW_SCORE: i32 = 0;
*/

fn main(){
    let x = 8; // 'let' binding 이라고 함
}

017

OWNERSHIP

fn main(){
    let country = String::from("대한민국");
    let ref_one = &country;
    let ref_two = &country;

    println!("Country is: {}", ref_one);
}

fn return_it() -> &String {
    let country = String::from("대한민국");
    &country // ref 반환
}

fn main(){
    let my_country = return_it(); // >> 오류!!
}

018

mutable references

& -> immutable reference / shared reference &mut -> mutable reference / unique reference

fn main(){
    let mut my_number = 9;
    let num_ref = &mut my_number;

    /* 이렇게 코딩하면 오류남!! 
    num_ref = 10;
    */

    *num_ref = 10; // &의 반대개념 *

    // && 이면 ** 사용!
    /*
        let num_ref = &mut &mut my_number;
        **num_ref = 10;
    */
}

019

references and shadowing

// 오류 반환됨!!
fn main(){
    let mut number = 10;
    let number_ref = &number;
    let number_change = &met number;
    *number_change += 10;
}

// 정상 작동됨
fn main(){
    let mut number = 10;
    let number_change = &met number;
    *number_change += 10;
    let number_ref = &number;
}

shadowing!

// 정상 작동됨
fn main(){
    let country = "대한민국";
    let country_ref = & country;
    let country = 8; // shadowing

    println!("{}, {}", country_ref, country); 
    // -> "대한민국" 이 없어지지 않았음을 확인할 수 있음!"
}

020

OWNERSHIP

fn print_country(country_name: String){
    println!("My country is {}", country_name);
}

fn main(){
    let country = "대한민국".to_string();
    print_country(country); // 여기서 country 의 소유권이 print_country 함수로 넘어감
    print_country(country); // 여기서 에러 발생!!
}

fn print_country(country_name: &String){
    println!("My country is {}", country_name);
}

fn main(){
    let country = "대한민국".to_string();
    print_country(&country); // 여기서 country 의 소유권은 넘어가지 않음!
    print_country(&country); // 에러 발생 X!
}

웹 IDE (rust전용)

https://play.rust-lang.org

• permalink to the playground : 코드를 포함한 ide 링크 복사가능

Rust 의 장단점

장점

• c, c++ 처럼 빠른속도

단점

• 어려움

002

comments (주석)

가장 기본적인 주석

// This is normal comment

Documentation 주석

/// This is normal comment

부분적인 주석

fn main() {
    let x/*: i16*/ = 10;
}

• 사용하지 않은 변수에 대해 언더스코어(_) 로 이름을 시작하게 되면 미사용변수에 대한 Warning 이 없음

003

Primitive types : 기본 데이터 타입

integer (정수, 음수 가능)

• i8, i16, i32, i64, i128, and isize

unsigned integer (부호없는 정수, 음수 불가능)

• u8, u16, u32, u64, u128, and usize

(i -> integer || u -> unsigned) + bit 수 로 표현

let my_number = 100; 

변수 선언 시 let 사용

my_number 는 어떤 타입인지 알 수 없음

-> u8타입을 지정하고 싶다면 다음과 같이 지정 가능

let my_number: u8 = 100; 

type inference

다음과 같은 코드에서는 컴파일러가 타입을 추론하여 계산함

let my_number: u8 = 100; 
let my_other_number = 50; // type 미지정, 기본 : i32(or i64)
let _third_number = my_number + my_other_number;

u8 + i64 연산은 기본적으로 안되지만, my_other_number 에 대해 타입지정을 안했기 때문에 컴파일러가 타입을 추론하여 연산할 수 있음.

다음과 같이 각 변수에 대해 타입이 지정돼있는 변수사이의 연산은 불가능

let my_number: u8 = 100; 
let my_other_number: u16 = 50; // u16 지정
let _third_number = my_number + my_other_number;

>> ERROR

004

Char

println!(String); 의 형태에서는 무조건 큰 따옴표 ("")를 사용하고, Char type 변수를 선언할 때에는 작은 따옴표 ('')를 사용

String : 문자열 Char : 문자

char type은 4bytes 크기

println!("Hello, world!");
let first_letter = 'A';
let space = ' ';

Casting

simple type change using 'as'

let my_number: u16 = 8;
let second_number: u8 = 10;
let third_number = my_number + second_number as u16;

Char -> u8 으로 캐스팅 하면 ASCII Code 가 됨

let my_number = 'a' as u8;
println!("Hello, world! My number is {}", my_number);

005

Char 와 String의 차이

Char type 의 크기는 4bytes

println!("Size of a char: {}", std::mem::size_of::<char>()); // 4bytes

Sring ("")타입의 크기는 .len()으로 알 수 있음

println!("Size of string containing 'a': {}", "a".len()); // 1 출력 = 1byte

글자수와 비슷하지만, 사실 글자수가 아닌 bytes 수

println!("Size of string containing 'ß': {}", "ß".len()); // 독일어 : 2bytes
println!("Size of string containing '国': {}", "国".len()); // 한자 : 3bytes
println!("Size of string containing '𓅱': {}", "𓅱".len()); // 고대 이집트어 : 4bytes

string의 bytes수가 아닌 글자수를 알려면?

.chars().count() 사용

let slice = "Hello!";
println!("Slice is {} bytes and also {} characters.", slice.len(), slice.chars().count());

// .chars() : "Hello!" -> 'H', 'e', 'l', ... , '!';

006

숫자형 (u8, u16, ...) 앞에 숫자를 넣어서 변수선언과 타입지정을 한번에 할 수 있음

// 중간에 underscore(_)는 아무리 많이 써도 상관없음
let my_number = 9_u8; // u8 타입의 9값을 가진 변수
let second_number = 1_000_000_000u64; 
let third_number = 9_____________1u32; 

Float

1. let float_number = 9.;
2. f32 / f64 로 타입지정(주로 f64사용)

   let f_number = 9.; // f64
   let s_number: f64 = 1.1;
   let t_number = 8; // i32
   println!("{}", f_number + s_number + t_number as f64); // 18.1

007

println!()

-> println meand print line -> ! means macro

매크로는 super function.

변수 사용({})기호를 사용하고 변수할당을 하지 않으면 에러 발생

let my_name = "David";
println!("My name is {}");

>> ERROR

function

fn func_name() -> return_type {
}

형식으로 함수 선언 가능

fn give_age() -> i32 {
    42 // return 42 라고 하지 않아도 됨!
}

fn main(){
    let my_name = "David";
    println!("My name is {} and my age is {}", my_name, give_age());
}

008

println!() - 2

{} 안에 변수명을 넣어서 사용 가능!

fn main(){
    let my_city = "Seoul";
    let year = 2002;
    let population = 9_987_987;
    println!("The city of {city} in {year} had a population of {population}",
    city = my_city,
    year = year,
    population = population);
}

{} 안에 변수 인덱스를 넣어서 사용 가능!

fn main(){
    let my_city = "Seoul";
    let year = 2002;
    let population = 9_987_987;
    println!("The city of {0} in {1} had a population of {2}. I love {0}",
    my_city,
    year,
    population);
}

string interpolation

fn main(){
    let city = "Seoul";
    let year = 2002;
    let population = 9_987_987;
    println!("The city of {city} in {year} had a population of {population}. I love {city}");
}

다음과 같이 expression(표현식)은 사용 불가능

fn main(){
    let city = "Seoul";
    let year = 2002;
    let population = 9_987_987;
    println!("The city of {city} in {year+2} had a population of {population}. I love {city}");
}

>> year+2 에서 Error

009

empty tuple

// 8을 반환하는 함수 number()
fn number() -> i32 {
    8
}

하지만 8 뒤에 세미콜론을 붙이게 된다면 에러 발생

// 8을 반환하는 함수 number()
fn number() -> i32 {
    8;
}

fn main() {
    let my_number = number();
}

/*
>> Error : expected i32 but found ()
() 는 Rust 에서 empty tuple, unit type 이라고 부르고 다른 언어에서는 void 라고 부름
*/

Display, Debug

• Display : {}
• Debug Print : {:?}

fn empty_tuple() {
}

fn main() {
    let tuple = empty_tuple();
    println!("{}", tuple); // error
    println!("{:?}", tuple); // 웬만해서는 출력 가능!
}

010

function

앞서 알아본 간단한 함수의 모양은 다음과 같음

fn give_number() -> i32 {
    8
}

fn main() {
    let my_number = give_number();
}

Parameter 를 받아서 반환하는 형태의 함수는 다음과 같음

fn give_number(one: i32, two: i32) -> i32 {
    one * two
}

fn main() {
    let my_number = give_number(9,8);
    println!("{}", my_number);
}

Code block 활용

fn give_number(one: i16, two: i16) -> i16 {
    let multiplied_by_ten = {
        let f_number = 10;
        f_number * one * two
    };
    multiplied_by_ten
}

fn main() {
    let my_number = give_number(9,8);
    println!("{}", my_number);
}

강의 링크 https://youtube.com/playlist?list=PLfllocyHVgsSJf1zO6k6o3SX2mbZjAqYE&si=LfVF7DHgzWT7iUrp

대시보드 구성

Node Exporter

시스템 리소스 정보(CPU, 메모리, 디스크, 네트워크 등)를 HTTP endpoint로 제공

• localhost:9100/metrics 로 시스템 리소스 정보를 제공

Prometheus

다양한 지표를 수집하고 저장하는 시스템

• 대상(예 : node-exporter) 에 주기적으로 접근하여 메트릭 데이터를 가져옴

Grafana

메트릭 데이터를 불러와 대시보드 형태로 시각화해주는 툴

관계 요약

설치 & 실행 & 설정

OS : Ubuntu, sudo su 로 관리자 계정에서 진행합니다.

Node Exporter

https://prometheus.io/download/#node_exporter

리눅스 버전의 다운로드 링크를 복사합니다.

wget 명령어를 통해서 압축파일을 다운받습니다.

wget https://github.com/prometheus/node_exporter/releases/download/v1.9.0/node_exporter-1.9.0.linux-amd64.tar.gz

압축파일 다운로드가 완료되었다면 아래 명령어로 파일이 존재하는지 확인합니다.

ls node_exporter*

파일이 존재한다면 압축을 풀어준 뒤, 압축해제된 경로로 이동합니다.

tar xzvf node_exporter-1.9.0.linux-amd64.tar.gz
cd node_exporter-1.9.0.linux-amd64

ls 명령어로 디렉토리의 파일 목록을 확인하면 다음과 같습니다

이제 node_exporter 파일을 /usr/local/bin 폴더로 옮겨줍니다.

mv node_exporter /usr/local/bin

파일을 옮겼다면, 시스템 서비스 등록을 합니다.

vim /etc/systemd/system/node-exporter.service

아래 내용을 복사 붙여넣기 한 뒤 저장합니다.

[Unit]
Description=Node Exporter
After=network.target

[Service]
User=nobody
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=default.target

서비스를 시작하고, 부팅 시 자동 실행하도록 설정합니다.

systemctl daemon-reexec
systemctl daemon-reload
systemctl start node-exporter
systemctl enable node-exporter

아래 명령어를 통해 시스템이 정상작동하고 있는지 확인합니다.

systemctl status node-exporter

curl http://localhost:9100/metrics

Prometheus

node-exporter 설정이 끝났으니 prometheus 를 설치해 봅니다.

먼저, Prometheus 시스템 그룹을 생성합니다.

groupadd --system prometheus

prometheus 사용자를 추가하고, 생성된 그룹에 할당해 줍니다.

useradd -s /sbin/nologin --system -g prometheus prometheus

그리고 prometheus를 위한 디렉토리를 생성해 줍니다.

mkdir /etc/prometheus

다음으로 아래 링크에 들어가서 프로메테우스 다운로드 링크를 복사합니다.

https://prometheus.io/download/#prometheus

LTS 버전을 받도록 하겠습니다.

wget 명령어를 통해서 압축파일을 다운받습니다.

wget https://github.com/prometheus/prometheus/releases/download/v2.53.4/prometheus-2.53.4.linux-amd64.tar.gz

압축파일을 풀어준 뒤 압축이 해제된 디렉토리로 이동해줍니다.

tar xzvf prometheus*.tar.gz
cd prometheus*/

해당 폴더에 있는 prometheus 바이너리 파일을 옮겨준 뒤 버전을 확인합니다.

mv prometheus promtool /usr/local/bin/
prometheus --version

그럼 이제 아까 만들어둔 prometheus 폴더에 구성 파일을 옮겨줍니다.

mv prometheus.yml /etc/prometheus/prometheus.yml
mv consoles/ console_libraries/ /etc/prometheus/

파일을 옮긴 뒤 구성파일의 내용을 확인해 줍니다.

cat /etc/prometheus/prometheus.yml

이제 프로메테우스 시스템을 등록합니다.

vim /etc/systemd/system/prometheus.service

위 명령어로 에디터를 열어서, 아래 내용을 붙여넣어 줍니다.

[Unit]
Description=Prometheus
Documentation=https://prometheus.io/docs/introduction/overview/
Wants=network-online.target
After=network-online.target
[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
--config.file /etc/prometheus/prometheus.yml \
--storage.tsdb.path /var/lib/prometheus/ \
--web.console.templates=/etc/prometheus/consoles \
--web.console.libraries=/etc/prometheus/console_libraries \
--web.listen-address=0.0.0.0:9090 \

[Install]
WantedBy=multi-user.target

/var/lib/prometheus/ 디렉토리를 storage path 로 설정해 놓았기 때문에, 해당 디렉토리를 생성하고, 권한을 부여합니다.

mkdir /var/lib/prometheus
chown -R prometheus:prometheus /var/lib/prometheus

이제 prometheus 설정은 끝났으니 실행시켜 봅니다.

systemctl daemon-reload
systemctl start prometheus
systemctl enable prometheus

잘 작동하고 있음을 확인할 수 있습니다.

node-exporter <> prometheus 연동

Prometheus 의 설정파일을 수정해줍니다.

vim /etc/prometheus/prometheus.yml

최하단에 있는 scrape_configs: 부분에 아래 내용을 추가해 줍니다.

- job_name: 'node-exporter'
    static_configs:
      - targets: ['localhost:9100']

prometheus를 재시작 하고, 연동이 잘 되었는지 확인합니다.

systemctl restart prometheus
curl http://localhost:9090/api/v1/targets

activeTargets 에 localhost:9100/metrics 가 있는지 확인합니다.

Grafana

먼저 apt 업데이트를 진행한 뒤, 필요 패키지를 다운받습니다.

apt update -y && sudo apt upgrade -y
apt install -y apt-transport-https software-properties-common wget

Grafana GPG 키를 추가해주어야 합니다.

아래 명령어를 통해 GPG 키를 다운받아 줍니다.

sudo mkdir -p /etc/apt/keyrings/
wget -q -O - https://apt.grafana.com/gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/grafana.gpg > /dev/null

Grafana APT 저장소를 추가해 준 뒤 grafana 를 설치해 줍니다.

echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list
apt update
apt install grafana

설치가 완료되었다면 제대로 설치가 되었는지 확인하고, 서비스를 시작합니다.

grafana-server -v

systemctl start grafana-server
systemctl enable grafana-server

systemctl status grafana-server

잘 동작하고 있는것을 확인할 수 있습니다.

grafana 가 동작하는 3000번 포트를 개방하고 접속해보겠습니다.

최초 자격증명은 admin/admin 입니다.

비밀번호를 변경하라는 창이 뜹니다만 skip 하겠습니다.

먼저 데이터 소스를 추가해 주겠습니다.

프로메테우스 클릭

connection 에는 http://localhost:9090 을 입력해줍니다.

제일 밑에 save&test를 누르면 쿼리에 성공했다는 메세지가 나옵니다.

그렇다면 다시 홈으로 돌아와서 dashboard 설정을 해보겠습니다.

우측 상단의 + 버튼을 누르고 import dashboard를 클릭

node exporter 기본 템플릿을 불러옵니다.

데이터 소스를 프로메테우스로 선택해주면

대시보드 설정 완료입니다.

여러개의 트랜잭션을 한번에 전송할 수 있게 도와주는 컨트랙트입니다.

장점

• 여러개의 트랜잭션을 한번에 묶어서 보내기 때문에 각각의 트랜잭션을 전송하는것 보다 가스비가 저렴할 수 있습니다.
• 트랜잭션에 대해 서명을 한 번만 하면 되기 때문에, UX향상을 기대할 수 있습니다.

Multicall 컨트랙트 주소

웬만한 네트워크에는 배포되어있는듯 합니다. 신기하게도 모든 네트워크에 배포된 컨트랙트 주소가 동일합니다

https://www.multicall3.com/deployments

Multicall Abi

아래 링크에서 확인할 수 있습니다.

https://www.multicall3.com/abi#json

사용법

• 여러개의 contract 에서 read 함수를 호출하여 결과를 종합하는 경우
• 여러개의 상태가 변경되는 함수를 호출하는 경우

🍏여러개의 contract 에서 read 함수를 호출하여 결과를 종합하는 경우

1. callData를 생성

    // callData 형식
    struct {
        target : contractAddress,
        callData : contract.interface.encodeFunctionData("methodName", [param1, param2, ...]
    }
   
    // contract instance 에서 functionData encoding
    const mulltiCallData = [
        {
            target : contractAddress1,
            callData : contract1.interface.encodeFunctionData("methodName1", [param1, param2, ...]
        },
        {
            target : contractAddress2,
            callData : contract2.interface.encodeFunctionData("methodName2", [param1, param2, ...]
        },
    ]
   
    // contractInterface instance 에서 functionData encoding
    const contractInterface1 = new ethers.Interface(ABI1)
    const contractInterface2 = new ethers.Interface(ABI2)
   
    const mulltiCallData = [
        {
            target : contractAddress1,
            callData : contractInterface1.encodeFunctionData("methodName1", [param1, param2, ...]
        },
        {
            target : contractAddress2,
            callData : contractInterface2.encodeFunctionData("methodName2", [param1, param2, ...]
        },
    ]

2. aggregate 함수 호출

    // ethers.js v6 기준!
   
    const multicallResultRaw = await multicallContract.aggregate.staticCall(multiCallData)

3. 호출결과를 decoding

    /*
    aggregate 반환값 형식 = [blockNumber , [ Result1, Result2, Result3, ... ]
    */
   
    // contract instance 에서 functionDataResult decoding
    const [ blockNum, results ] = multicallResultRaw
    const [ result1, result2 ] = [
        contract1.interface.decodeFunctionResult("methodName1",results[0]),
        contract2.interface.decodeFunctionResult("methodName2",results[1]),
    ]
   
    // contractInterface instance 에서 functionDataResult decoding
    const [ result1, result2 ] = [
        contractInterface1.decodeFunctionResult("methodName1",results[0]),
        contractInterface2.decodeFunctionResult("methodName2",results[1]),
    ]

• 코드예시

    async function main() {
      const rpcUrl = "https://api.avax-test.network/ext/bc/C/rpc";
      const provider = new ethers.JsonRpcProvider(rpcUrl);
      const multicallContractAddress = "0xcA11bde05977b3631167028862bE2a173976CA11";
  
      const multicallContract = new ethers.Contract(
        multicallContractAddress,
        multicallAbi,
        provider
      );
  
      const token0Address = "0x2B4931ab37d33AE909d605476168F90E10C1A9e4";
      const token1Address = "0xb13BebA6d96244C38dcbcbd448303351BaF7723c";
  
      const tokenInterface = new ethers.Interface(tokenAbi);
  
      const multiCallData = [
        {
          target: token0Address,
          callData: tokenInterface.encodeFunctionData("name"),
        },
        {
          target: token0Address,
          callData: tokenInterface.encodeFunctionData("symbol"),
        },
        {
          target: token1Address,
          callData: tokenInterface.encodeFunctionData("name"),
        },
        {
          target: token1Address,
          callData: tokenInterface.encodeFunctionData("symbol"),
        },
      ];
  
        // only call once
      const [, [token0NameRaw, token0SymbolRaw, token1NameRaw, token1SymbolRaw]] =
        await multicallContract.aggregate.staticCall(multiCallData);
  
      const [token0Name] = tokenInterface.decodeFunctionResult(
        "name",
        token0NameRaw
      );
      const [token0Symbol] = tokenInterface.decodeFunctionResult(
        "symbol",
        token0SymbolRaw
      );
      const [token1Name] = tokenInterface.decodeFunctionResult(
        "name",
        token1NameRaw
      );
      const [token1Symbol] = tokenInterface.decodeFunctionResult(
        "symbol",
        token1SymbolRaw
      );
  
      console.log(token0Name);
      console.log(token0Symbol);
      console.log(token1Name);
      console.log(token1Symbol);
    }

🍏여러개의 contract 에서 state-changing 함수를 호출하여 결과를 종합하는 경우

1. callData를 생성

    // callData 형식
    struct {
        address target;
        bool allowFailure; // false 일 경우 해당 callData 호출 실패시, 전체 트랜잭션이 revert됨
        bytes callData;
    }
   
    // contract instance 에서 functionData encoding
    const mulltiCallData = [
        {
            target : contractAddress1,
            allowFailure : true,
            callData : contract1.interface.encodeFunctionData("methodName1", [param1, param2, ...]
        },
        {
            target : contractAddress2,
            allowFailure : false,
            callData : contract2.interface.encodeFunctionData("methodName2", [param1, param2, ...]
        },
    ]
   
    // contractInterface instance 에서 functionData encoding
    const contractInterface1 = new ethers.Interface(ABI1)
    const contractInterface2 = new ethers.Interface(ABI2)
   
    const mulltiCallData = [
        {
            target : contractAddress1,
            allowFailure : true,
            callData : contractInterface1.encodeFunctionData("methodName1", [param1, param2, ...]
        },
        {
            target : contractAddress2,
            allowFailure : false,
            callData : contractInterface2.encodeFunctionData("methodName2", [param1, param2, ...]
        },
    ]

2. aggregate3 함수 호출

    // ethers.js v6 기준!
   
    const tx = await multicallContract.connect(wallet).aggregate3(multiCallData)
    await tx.wait()

• 코드예시

    const multicallData2 = [
        {
          target: token0Address,
          allowFailure: true,
          callData: tokenInterface.encodeFunctionData("faucet", [tokenAmount]),
        },
        {
          target: token0Address,
          allowFailure: true,
          callData: tokenInterface.encodeFunctionData("transfer", [
            wallet.address,
            tokenAmount,
          ]),
        },
        {
          target: token1Address,
          allowFailure: true,
          callData: tokenInterface.encodeFunctionData("faucet", [tokenAmount]),
        },
        {
          target: token1Address,
          allowFailure: true,
          callData: tokenInterface.encodeFunctionData("transfer", [
            wallet.address,
            tokenAmount,
          ]),
        },
      ];
  
      const tx = await multicallContract.connect(wallet).aggregate3(multicallData2);
  
      await tx.wait();
  
      const token0BalanceAfter = await token0Contract.balanceOf(wallet.address);
      const token1BalanceAfter = await token1Contract.balanceOf(wallet.address);
  
      console.log(
        `Token0 Balance : ${ethers.formatEther(
          token0BalanceBefore
        )} -> ${ethers.formatEther(token0BalanceAfter)}`
      );
  
      console.log(
        `Token1 Balance : ${ethers.formatEther(
          token1BalanceBefore
        )} -> ${ethers.formatEther(token1BalanceAfter)}`
      );

💡multicall 을 통해 함수를 실행할 때 주의해야할 점

• msg.sender 가 multicall contract Address 가 되기 때문에 transfer, approve같은 메서드를 호출할 때 메서드 실행주체에 대해 잘 생각해야함.

실행결과 tx 정보 확인 → https://testnet.snowtrace.io/tx/0x3395ec1e1888acc7e91f78f4b4969f6cde93e43d881fc37086f80bc8c2d8a94d/internal?chainid=43113

Multicall Contract 와 import 된 Multicall 차이점

Multicall Contract

Multicall Contract 를 통해 tx 를 전송하게 될 경우 구조는 다음과 같습니다.

[ Wallet ] → [ Multicall Contract ] → [ Target Contract ]

따라서 Target Contract 입장에서 tx의 주체, 즉 msg.sender 는 Multicall Contract가 됩니다.

상황 예시

• 내 지갑(W0)에 90 TokenA 가 있다.
• (W1, W2, W3) 에 30 TokenA 씩 전송하려고 한다.
• ( token.transfer ) 트랜잭션 3개를 multicall로 전송한다.
• multicall은 3개의 트랜잭션을 TokenA 컨트랙트로 전송한다.
• 이때, transfer의 호출 주체(msg.sender) 는 multicall contract 이고, multicall contract 는 tokenA 잔액이 0 이기 때문에 모든 트랜잭션이 revert 된다.

코드를 살펴보면, multicall Contract 가 target Contract로 callData 를 그대로 전송하고 있습니다.

import 된 Multicall

위 사진과 같이 Multicall 을 상속받는 경우는 조금 다른 부분이 있습니다.

위 코드에서 상속받은 Multicall 코드를 살펴보면 다음과 같이 작성돼있습니다.

여기서는 delegatecall 을 사용하여 tx를 처리하고 있음을 확인할 수 있습니다.

delegateCall 은 특정 함수를 호출할 때 msg.sender 와 msg.value를 그대로 유지하여 트랜잭션을 전송하게 됩니다.

상황 비유

예시 상황으로 두 방법에 대해 정리하자면,

상황 : 사람A 가 사람B 에게 중간 매개자(사람C)를 통해 물건을 전송하는 상황.

• Multicall Contract를 사용한다면
  1. 사람A 가 사람C에게 물건을 전달한다. 물건에는 [보낸 사람 : 사람A] 라고 적혀있다.
  2. 사람C 가 사람B에게 물건을 전달한다. 물건에는 [보낸 사람 : 사람C] 라고 적혀있다.
• import된 Multicall 을 사용한다면
  1. 사람A 가 사람C에게 물건을 전달한다. 물건에는 [보낸 사람 : 사람A] 라고 적혀있다.
  2. 사람C 가 사람B에게 물건을 전달한다. 물건에는 [보낸 사람 : 사람A] 라고 적혀있다.

정리

• Multicall Contract
  • "한번에" 여러개의 target Contract로, 여러개의 트랜잭션을 보낼 수 있는것
  • 트랜잭션의 주체가 multicall Contract
• import된 Multicall
  • 한번에 여러개의 트랜잭션을 보낼 수 있지만, target Contract는 해당 컨트랙트로만 한정
  • 트랜잭션의 주체가 wallet(caller)

CPMM

uniswapV2 에서는 CPMM (Constant Product Market Maker)을 사용합니다. 다른건 몰라도 이것만 알면 됩니다.

x * y = k

뭔가 복잡해보이는 이름에 걸맞지 않는 간단한 수식입니다. 매우 간단해 보여도 uniswapV2의 핵심이 되는 수식이니 잘 이해해야합니다. 위의 수식이 어떻게 사용되는지 예시를 통해 알아봅시다.

유동성(Liquidity)

유동성이란 거래를 위해 사용될 수 있는 자산을 의미합니다.

Swap

swap은 "교환"과 같은 의미입니다.

사과를 구매하려는 사람의 이야기로 예시를 들어보겠습니다.

금화를 1개 가지고 있는 사람A가 사과를 구매하려고 한다.

길을 가다 한 무인과일가게에 들어가서 보니
상자에 금화 100 개와 사과 101개가 들어있었다.

옆에 종이에는 이렇게 적혀있었다.

"상자에 남아있는 금화와 사과의 개수의 곱은 항상 10100 이어야합니다."

사람A 는 상자에 금화를 한개 넣고 사과를 하나 뺐다.

상자에 남은건 금화 101개와 사과 100개로 두 수의 곱은 10100으로 변함이 없다.

여기서 가장 핵심적이 되는 부분은 금화의 개수와 사과의 개수의 곱이 10100로 일정했다는 것입니다. 그렇다면 금화(x)와 사과(y)의 현재 개수를 알면 지불하는 금화(혹은 사과)의 양에 대해 수령하게 되는 사과(혹은 금화)의 양을 계산할 수 있다는 것입니다.

간단하게 수식으로 정리하면

• reserve0(금화 개수) = r0
• reserve1(사과 개수) = r1
• k = r0 * r1
• amount0In(지불하는 금액) = amt0In
• amount1Out(수령하는 금액) = amt1Out

(r0 + amt0In)(r1 - amt1Out) = k

위 식을 다시 위의 사과예시에 대입해보면 다음과 같습니다.

k = r0(금화의 유동성=100) * r1(사과의 유동성=101) = 10100 (r0(금화의 유동성=100) + amt0In(A가 지불한 금화=1)) * (r1(사과의 유동성=101) - amt1Out(A가 받게 될 사과의 개수)) = k

Price Impact

CPMM 특성 상 같은 금액을 지불해도 유동성 풀 규모에 따라 받게되는 금액이 차이가 납니다.

50개의 token0 을 token1로 swap 하는 상황에서 예를 들어보겠습니다.

• 금화가 100개, 사과가 1000개 라고 했을 때
  • 금화 : 사과 = 1 : 10
  • 금화 50개에 대한 사과의 기대수량 = 500개
  • 실제 스왑량
    • (100 + 50) * (1000 - 사과) = 100000
    • 사과 개수 ≈ 333.333
  • PriceImpact = (1 - 실제수량 / 기대수량) * 100 ≈ 33.33%
• 금화가 10,000,000개, 사과가 100,000,000개 라고 했을 때
  • 금화:사과 = 1: 10
    • 금화 50개에 대한 사과의 기대수량 : 500개
  • 실제 스왑량
    • (10,000,000+50) * (100,000,000 - 사과) = 1,000,000,000,000,000
    • 사과 개수 ≈ 499.998
  • PriceImpact = (1 - 실제수량 / 기대수량) * 100 ≈ 0.0004%

유동성이 클 수록 기대수량에 대한 오차가 작아집니다.

유동성 공급/제거와 수수료에 대한 내용은 다음편에서..