crypt0summer

You-Dont-Know-JS - 2

_April — Tue, 9 Jan 2024 17:42:40 +0900

1. Get Started

1) What Is JavaScript?

-Name

This language was originally designed to appeal to an audience of mostly Java programmers, and because the word "script" was popular at the time to refer to lightweight programs.

So the official name of the language specified by TC39( the technical steering committee that manages JS ) and formalized by the ECMA standards body is ECMAScript. The JavaScript/JS that runs in your browser or in Node.js, is an implementation of the ES2019 standard.

-Language spec

The official standard as maintained by TC39 and ECMA.

-Web and JS

How it should be : How JS is implemented for web browsers is, in all practicality, the only reality that matters.

Reality: Sometimes the JS engines will refuse to conform to a specification-dictated change because it would break that web content.

Solution: Appendix B details out any known mismatches between the official JS specification and the reality of JS on the web.

-Not all web JS

Web API: alert(..) console.log(..)

Node.js: fetch(..), getCurrentLocation(..), and getUserMedia(..)

-Not always JS

console/REPL in your browser's Developer Tools as a "JS-friendly" environment. It doesnt' represent exact to-the-letter JS semantics

-multi-paradigm language

Typical paradigm-level code categories include procedural, object-oriented (OO/classes), and functional (FP)

JavaScript is most definitely a multi-paradigm language. You can write procedural, class-oriented, or FP-style code

-backwards compatibility ( 이전 버전과 호환성유지)

하위호환: 웹페이지는 브라우저의 자바스크립트 엔진으로 구동되기 때문에 아주 옛날의 웹페이지도 돌아가게 만들어야 했습니다.

상위호환: 예전의 브라우저들은 상위 버전의 자바스크립트에서 만든 웹페이지들을 구동시킬수 없습니다. 즉 상위 호환이 차단됩니다.

-Gaps : jumping and filling

상위호환을 지원하지 않는 JS에서 이와 비슷한 (하위 버젼에서 돌려야 하는) 상황이 온다면 어떻게 해결해야 할까요? 이런 상황을 겪은 많은 개발자들이 다양한 해결책을 내놓았는데, 대표적으로는 Transpiling과 Polyfill이 있습니다. Transpiling은 작성한 코드를 변환해, Polyfill은 스펙을 비슷하게 구현해 코드에 추가해 구 버젼에서 신 스펙을 사용할 수 있습니다.

-interpretation

scripted or interpreted languages : 'top-down', 'line-by-line'

compiled languages : Parsing + Compilation + Execution

>> 바이너리 파일로 만드는 과정 중 코드를 파싱(Parsing)해 추상 문법 트리 (Abstract Syntax Tree)로 변환하는 과정을 거칩니다. 아까 5번째 줄에 에러가 존재하는 상황이 컴파일 언어에 발생된다면, 파싱 과정에서 에러가 발생합니다.

JS: compiled lang because JS source code is parsed(compiled) before it is executed.

-Web assembly

JS's performance is remarkable, it can be parsed/compiled quickly and compiled code can be executed fast.
An initial motivation for WASM was clearly the potential performance improvements. While that continues to be a focus, WASM is additionally motivated by the desire to bring more parity for non-JS languages to the web platform.

-Strict mode

Strict mode: a guide to the best way to do things so that the JS engine has the best chance of optimizing and efficiently running the code.

2) Surveying JS

-Each file is a program

In JS, each standalone file is its own separate program.

! Many projects use build process tools that end up combining separate files from the project into a single file to be delivered to a web page. When this happens, JS treats this single combined file as the entire program.

-Values

a program is a value. Values are data. They're how the program maintains state. Values come in two forms in JS: primitive and object.

6 primitives are: literals, booleans, numbers(include bigint), null, undefined, symbol

interpolation :``

other primitive values in JS programs are null and undefined. However, it's safest and best to use only undefined as the single empty value, even though null seems attractive

-Arrays and Objects

arrays are a special type of object

Functions, like arrays, are a special kind (aka, sub-type) of object.

Objects are more general: an unordered, keyed collection of any various values.

-Value type determination

coercion: Converting from one value type to another, such as from string to number

typeof 42;                  // "number"
typeof "abc";               // "string"
typeof true;                // "boolean"
typeof undefined;           // "undefined"
typeof null;                // "object" -- oops, bug!
typeof { "a": 1 };          // "object"
typeof [1,2,3];             // "object"
typeof function hello(){};  // "function"

-Declaring and Using Variables

var / let / const

let allows a more limited access to the variable than var. This is called "block scoping" as opposed to regular or function scoping.

const. It's like let but has an additional limitation that it must be given a value at the moment it's declared, and cannot be re-assigned a different value later.

It's ill-advised to use const with object values, because those values can still be changed even though the variable can't be re-assigned.

-Functions

A procedure is a collection of statements that can be invoked one or more times, may be provided some inputs, and may give back one or more outputs.
JS functions are a special type of the object value type. It can be assigned and passed around.

-Comparisions

=== > checking both the value and the type
JS does not provide a mechanism for structural equality comparison of object values, only reference identity comparison.

-Coercive Comparisons

== allows type conversions first: instead of loose equality it is called coercive comparisions

-Organization: Classes, Modules

A class in a program is a definition of a "type" of custom data structure that includes both data and behaviors that operate on that data. Classes define how such a data structure works, but classes are not themselves concrete values. To get a concrete value that you can use in the program, a class must be instantiated

The module pattern has essentially the same goal as the class pattern, which is to group data and behavior together into logical units. Also like classes, modules can "include" or "access" the data and behaviors of other modules

I'd recommend sticking with classic modules instead of class.

3) Digging to the Roots of JS

- Iteration

- Closure

- this keyword

- Prototypes

- Object Linkage

4) The Bigger Picture

-Scope and Closure

-Prototypes

- 3 pillars

You-Dont-Know-JS -1

_April — Tue, 9 Jan 2024 17:21:31 +0900

https://github.com/getify/You-Dont-Know-JS/tree/2nd-ed?tab=readme-ov-file

GitHub - getify/You-Dont-Know-JS: A book series on JavaScript. @YDKJS on twitter.

A book series on JavaScript. @YDKJS on twitter. Contribute to getify/You-Dont-Know-JS development by creating an account on GitHub.

github.com

INDEX

1. Get Started

2. Scope & Closures

3. Objects & Classes

4. Types & Grammar

1. Get Started

1) What Is JavaScript?

2) Surveying JS

3) Digging to the Roots of JS

4) The Bigger Picture

2. Scope & Closures

1) What's the Scope?

2) Lexical Scope

3) The Scope Chain

4) Around the Global Scope

5) The (Not So) Secret Lifecycle of Variables

6) Limiting Scope Exposure

7) Using Closures

8) The Module Pattern

3. Objects & Classes

1) Object Foundations

2) How Objects Work

3) Classy Objects

4) This Works

5) Delegation

4. Types & Grammar

1) Primitive Values

2) Primitive Behaviors

3) Object Values

4) Coercing Values

Git 사용자이름/이메일 설정

_April — Mon, 19 Jun 2023 17:21:01 +0900

로컬에서 기본값으로 사용할 Git 사용자 이름과 이메일 설정(global 옵션)

현재 시스템의 모든 Git 작업에 사용할 사용자 이름과 이메일을 설정하고자 한다면, global옵션을 사용해 git config 명령어를 실행한다.

$ git config --global user.name "Your Name"
$ git config --global user.email you@example.com

잘 설정되었는지 확인하는법

$ git config user.name
$ git config user.email

저장소 별로 Git 사용자와 이메일 정보 설정하기

저장소 디렉터리에서 --global 없이 git config를 사용하면 해당 디렉터리(저장소) 전용 설정을 추가할 수 있다.

$ git config user.name "realapril"
$ git config user.email realapril25@gmail.com

global 옵션으로 설정한 정보보다 우선적으로 설정된다.

Git 사용자 이름과 이메일 정보 삭제하기

# 전역 설정을 삭제
$ git config --global --unset user.name
$ git config --global --unset user.email

# 개별 저장소의 설정을 삭제
$ git config --unset user.name
$ git config --unset user.email

Zero-Knowledge Rollups(1) 배경

_April — Thu, 1 Dec 2022 15:59:15 +0900

탈중앙화와 보안이 장점인 이더리움에는 고질적인 문제가 있다. 느리고 비싸다는 것이다.

그래서 이 문제를 해결하기 위한 "scaling solutions" 가 여러가지 제시되었다.

주로 3가지 방식인데, L1 scaling, L2 scaling, side chain 이 있다.

L1 스케일링 경우에는 샤딩을 이용한 스케일링을 고려중이고

L2 스케일링의 경우에는 Rollups 솔루션이라고 불리는데 가스비가 100배까지 싸질수 있다고 한다. 별개의 네트워크에서 트랜젝션을 이루어지고, 이 트랜젝션들을 배치로 묶어서 이더리움체인(L1) 에서 검증받게 하는것이 요지이다. 검증법은 크게 두가지로 나뉜다.

(레이어2란: 이더리움을 연장하지만 이더리움과는 분리된 블록체인으로, 이더리움의 보안을 계승한다.)

L2 스케일링의 경우 optimistic rollup 과 zk rollup 으로 나뉜다.

Optimistic rollup 의 경우에는 일단 l2에서 이루어진 트랜젝션이 맞다고 가정하고, 검증자들이 fraud proof 를 증명해야한다.

그래서 생기는 단점이 있는데, fraud proof 를 제공할 시간을 줘야하는데 보통 1주일정도 준다. 즉 L2->L1로 자산이 돌아오는데 일주일이 걸려버린다.

폴리곤의 플라즈마체인도 fraud proof 를 쓴다

ZK rollup 의 경우에는 L2 에서 이루어진 배치가 L1 에 있는 컨트랙트를 통과해야한다. validity proof 를 제출해서 이게 맞다고 인정받아야한다.

이렇게하면 즉시(~12 seconds) L2->L1 이동이 가능하나 대신 (1)개발난이도가 높고(아직 zk가 evm 에서 쓸수있게 만들고있는 상태) (2)이더리움 노드가 걸리는 연산 부하가 높다.

근데 연산 부하쪽은 롤업에 따라 다르게 들긴하는데

이더리움이 초당 15~45개의 트렌젝션에서 최대 1000~4000 트젝을 처리할수 있어야 자유롭게 사용할수 있다.

현재는 이렇게까지 나오지 못하는 상태.

https://merge.nansen.ai/ 를 살펴봤더니 한 블록에 트젝수 최대 517개까지봤는데 TPS 니까 517/12= 43.. 최저 조건을 맞춘셈이다.

이게 이더리움 합의계층을 실행계층과 분리하여 만드는 이유이다(ETH2라는 명칭은 폐기됨)

현재 zk rollup 에서는

zksnark(zkSync) 와 starknet(starkware) 가 투탑이다.

https://ethereum.org/en/layer-2/

공홈에나와있듯 성숙한 단계는아니다.

이더리움 스마트컨트랙트 스토리지 이해하기

_April — Wed, 30 Nov 2022 15:55:05 +0900

https://programtheblockchain.com/posts/2018/03/09/understanding-ethereum-smart-contract-storage/

를 번역해보았다.

이더리움 스마트컨트랙트는 독특한 스토리지 모델을 사용하고, 이는 뉴비 개발자들을 혼란시킵니다.

이 포스트에서는 스마트컨트랙트 스토리지 모델을 설명하고, 솔리디티 프로그래밍에서 어떻게 사용하는지를 설명합니다.

1. 1개의 천문학적으로 큰 어레이

2. 고정 크기값 위치하기

3. 다이나믹 사이즈 값들 위치하기

(1)다이나믹 사이즈 어레이

(2)매핑

(3)여러타입들의 조합

1. 1개의 천문학적으로 큰 어레이

EVM 에서 작동하는 각각의 스마트컨트랙트는 각각의 영구적인 스토리지를 가진다. (storage hash)

이 스토리지는 하나의 거대한 어레이이며, 초기값은 0이라고 생각될수있다.

어레이의 하나의 값은 32바이트 크기이며, 이러한 32바이트가 2^256개 있다.

스마트 컨트랙트는 어떤위치의 값이라도 읽거나 쓸수있다.

이게 스토리지 인터페이스의 범위이다.

이런식의 거대한 하나의 어레이라고 상상해보자.

사실 이더리움의 스토리지는 이렇게 생기지 않았지만, 이렇게 하나의 거대한 어레이라고 생각하는 편이 이해하기 쉽다.

실제 스토리지는 극단적으로 희박하여 0까지 저장할 이유가 없다.

키/밸류 스토어 매핑으로 충분하다.(키,밸류 모두 32바이드 밸류) 키가 없는 경우에는 0값을 돌려주면 되기 때문이다.

0은 아무런 자리도 차지하지않아서, 값을 0으로 지정한다면 스토리지는 되돌려진다. 이게 스마트컨트랙트에서 "가스 리펀" 을 받는 경우이다.

2. 고정된 크기의 값 위치하기

이 스토리지 모델에서 값들은 어디로 가는가? 고정된 크기의 알려진 변수들은, 스토리지의 지정된 장소로 주면 된다. 솔리디티언어가 그걸한다.

contract StorageTest {
    uint256 a;
    uint256[2] b;

    struct Entry {
        uint256 id;
        uint256 value;
    }
    Entry c;
}

이런 코드가 있다고 치자.

a는 슬랏 0 에 저장된다
b는 슬랏 1, 2에 저장된다
c는 슬랏 3,4에 저장된다. Entry 내에 32바이트 값이 두개 있기 때문이다.

이 슬랏들은 컴파일될때 결정되고, 컨트랙트에 쓰여진 순서대로 할당된다.

3. 다이나믹 사이즈 값들 위치하기

다이나믹사이즈 어레이와 매핑의 경우엔 몇개의 슬랏을 사용하게 될지 모르기때문에 선지정할수 없다.

램이나 하드를 예시로 생각해보면, 빈 공간을 사용하기 위해 할당하는 단계와 사용중인 공간을 릴리즈하는 단계가 있을것이다.

그러나 스마트컨트랙트 스토리지경우엔 천문학적 규모때문에 그럴필요가없다.

스토리지에는 2^256 개의 위치가있는데, 이게 얼마나 큰 수냐면 관찰 가능한 우주의 원자의 수와 비슷할 정도다. 아무 위치를 랜덤으로 찍어도 충돌할 확률이 몹시 작다는 뜻이다. 심지어 이렇게 찍은 위치간에 멀리 떨어져있어서 다이나믹한 데이터를 얼마나 넣던 충돌할 가능성도 적다.

물론 위치를 진짜로 랜덤으로 설정하지는 않는다. 이러면 나중에 데이터를 찾을수가 없기때문이다. 솔리디티는 해시 펑션을 이용해 다이나믹 사이즈의 값의 위치를 통일성있게, 반복적으로 정한다.

(1) 다이나믹 사이즈 어레이

contract StorageTest {
    uint256 a;     // slot 0
    uint256[2] b;  // slots 1-2

    struct Entry {
        uint256 id;
        uint256 value;
    }
    Entry c;       // slots 3-4
    Entry[] d;
}

다이나믹 사이즈 어레이 d는 5번째 슬롯에 저장되지만, 정확히 5번째 슬롯에는 d의 크기만 저장된다.

어레이의 값은 슬롯의 해시 (hash(5)) 슬롯부터 순서대로 저장된다.

솔리디티에서는 다음과 같이 위치를찾는다

function arrLocation(uint256 slot, uint256 index, uint256 elementSize)
    public
    pure
    returns (uint256)
{
    return uint256(keccak256(slot)) + (index * elementSize);
}

(2) Mappings

매핑은 주어진 키에 대응하는 위치를 찾을 효율적인 방법을 요구한다. 키를 해싱하는것은 좋은 시작이지만, 다른 매핑이 다른 위치를 생성하도록 신경써야한다.

contract StorageTest {
    uint256 a;     // slot 0
    uint256[2] b;  // slots 1-2

    struct Entry {
        uint256 id;
        uint256 value;
    }
    Entry c;       // slots 3-4
    Entry[] d;     // slot 5 for length, keccak256(5)+ for data

    mapping(uint256 => uint256) e;
    mapping(uint256 => uint256) f;
}

e 슬롯의 위치는 6, f슬롯의 위치는 7이다. 그러나 6,7에 실제 데이터가 저장되지않는다. 이번엔 저장될 길이도 없고, 각개 데이터는 다른 어딘가에 저장되어야한다.

매핑의 경우에는 키와 매핑의 슬롯이 함께 해시된다.

매핑의 위치와 키가 함께 해싱되기때문에 충돌을 방지할수있다.

솔리디티에서는 다음과 같이 위치를찾는다.

function mapLocation(uint256 slot, uint256 key) public pure returns (uint256) {
    return uint256(keccak256(key, slot));
}

(3) 복잡한 타입들의 컴비네이션

다이나믹사이즈 어레이와 매핑은 서로 재귀적 중첩이 가능하다. 이게 발생하면 위의 계산이 재귀적으로 발생한다.

contract StorageTest {
    uint256 a;     // slot 0
    uint256[2] b;  // slots 1-2

    struct Entry {
        uint256 id;
        uint256 value;
    }
    Entry c;       // slots 3-4
    Entry[] d;     // slot 5 for length, keccak256(5)+ for data

    mapping(uint256 => uint256) e;    // slot 6, data at h(k . 6)
    mapping(uint256 => uint256) f;    // slot 7, data at h(k . 7)

    mapping(uint256 => uint256[]) g;  // slot 8
    mapping(uint256 => uint256)[] h;  // slot 9
}

이런게있으면 g[123][0]을 찾고자하면

g[123]을 먼저 찾고 -> g의 슬롯인 8과 키값으로 위치를 찾는다

그 후 arr[0]을 찾게된다. -> g[123]값을 해싱하면 첫 위치가 나온다. g[123]에는 어레이의 길이가 들어있으므로 길이만큼 값을 가져오면 된다.

h[2][456]을 찾고자하면

h[2] 는 슬롯9번을 해싱한 위치에 있고, 그중 2번째인 값을 가져온다.

요약

-각 스마트컨트랙트는 2^256개의- 한 슬랏은 32바이트가 들어가는- 형태의 어레이이며 모두 0으로 초기화된 셈이다.

-0은 명시적으로 저장되어있지않으므로 값을 0으로 세팅하는것은 그 스토리지를 요구하는 것이다.

-솔리디티는 고정된 사이즈의 값을 "슬롯"이라는 지정된위치에 지정시킨다. 이 슬랏은 0부터 시작한다.

-솔리디티는 다이나믹 사이즈 값들을 균일하고 안전히 저장하기 위해 해시 결과값을 쓴다.

calling another contract : interface vs call vs delegate call

_April — Mon, 29 Aug 2022 11:45:08 +0900

솔리디티 컨트랙트에서 다른 컨트랙트를 부르는방식은 여러가지가 있다.

interface, call, delegate call 에 대해 살펴보자. (static call은 일단 제외)

1) 코드상(사용방법상) 차이

2) 소모되는 가스 unit 차이

3) Low / High level function

4) 최종 컨트랙트의 msg. sender, 데이터 저장위치

(packing, unpacking 때문에 한가지 contract 사용보단 무조건 비쌈)

이 세가지에 대해 정리, 테스트해본다.

1 코드상(사용방법상) 차이

(0) 불릴 코드 (Callee)

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

contract Callee {
    uint public value1;
    uint public value2;

    struct template {
        uint256 tCount;
        uint256 tValue;
    }

    mapping(uint256 => template) templateList;

    function setV1(uint _value1) external returns (uint) {
        value1 = _value1;
        return value1;
    }

    function setV1andV2(uint _value1, uint _value2) external payable returns (uint, uint) {
        value1 = _value1;
        value2 = _value2;

        return (value1, value2);
    }

    function setTemplate(uint256 idx , template memory _template) external returns (bool) {
        templateList[idx] = _template;
        return true;
    }

    function setTemplateForJS(uint256 idx , uint256 _val1, uint256 _val2) external returns (bool) {
        template memory _template = template({
            tCount: _val1,
            tValue: _val2
        });
        templateList[idx] = _template;
        return true;
    }

    function getTemplate(uint256 idx) external view returns (template memory) {
        return templateList[idx];
    }

    
}

다른 컨트랙트에서 불릴수도있고, js 에서도 바로 불릴수 있는 코드이다(setTemplateForJS)

(1) interface

// contracts/Box.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "hardhat/console.sol";

interface ICallee {
    struct template {
        uint256 tCount;
        uint256 tValue;
    }

    function setV1(uint256 _value1) external returns (uint256);

    function setV1andV2(uint256 _value1, uint256 _value2)
        external
        payable
        returns (uint256, uint256);

    function setTemplate(uint256 idx, template memory _template)
        external
        returns (bool);

    function getTemplate(uint256 idx) external view returns (template memory);
}

contract Caller_interface {
    address internal _calleeAddr;

    constructor(address _calleeAddr_) {
        _calleeAddr = _calleeAddr_;
    }

    function setV1(uint256 _v1) public {
        uint256 x = ICallee(_calleeAddr).setV1(_v1);
        console.log("setV1: %s", x);
    }

    function setV1andV2(uint256 _v1, uint256 _v2) public {
        (uint256 x, uint256 y) = ICallee(_calleeAddr).setV1andV2(_v1, _v2);
        console.log("setV1andV2: %s, %s", x, y);
    }

    function setTemplate(
        uint256 idx,
        uint256 _val1,
        uint256 _val2
    ) public {
        ICallee.template memory temp = ICallee.template({
            tCount: _val1,
            tValue: _val2
        });
        bool x = ICallee(_calleeAddr).setTemplate(idx, temp);
    }


    function getTemplate(uint256 _idx) public {
        ICallee.template memory temp = ICallee(_calleeAddr).getTemplate(_idx);
    }
}

인터페이스로 부를수있는 코드이다

(2) call

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "hardhat/console.sol";

contract Caller_call {
    address internal _calleeAddr;

    constructor(address _calleeAddr_) {
        _calleeAddr = _calleeAddr_;
    }

    function setV1(uint256 _v1) public {
        (bool success, bytes memory result) = _calleeAddr.call(
            abi.encodeWithSignature("setV1(uint256)", _v1)
        );
        if(success){
            uint x = abi.decode(result, (uint));
            console.log("setV1: %s", x);
        }
    }

    function setV1andV2(uint256 _v1, uint256 _v2) public {
        (bool success, bytes memory result) = _calleeAddr.call(
            abi.encodeWithSignature("setV1andV2(uint256,uint256)", _v1, _v2)
        );
        (uint256 x, uint256 y) = abi.decode(result, (uint256, uint256));
        console.log("setV1andV2: %s, %s", x, y);
    }

    function setTemplate(
        uint256 idx,
        uint256 _val1,
        uint256 _val2
    ) public {
        
        (bool success, bytes memory result) = _calleeAddr.call(
            abi.encodeWithSignature("setTemplate(uint256,(uint256,uint256))",idx,  _val1, _val2)
        );
        console.logBytes(result);
    }


    function getTemplate(uint256 _idx) public {
     

        (bool success, bytes memory result) = _calleeAddr.call(
            abi.encodeWithSignature("getTemplate(uint256)",_idx)
        );
        console.logBytes(result);

    }
}

(3) delegate call

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "hardhat/console.sol";

contract Caller_delegateCall {
    address internal _calleeAddr;

    constructor(address _calleeAddr_) {
        _calleeAddr = _calleeAddr_;
    }

    function setV1(uint256 _v1) public {
        (bool success, bytes memory result) = _calleeAddr.delegatecall(
            abi.encodeWithSignature("setV1(uint256)", _v1)
        );
        if(success){
            uint x = abi.decode(result, (uint));
            console.log("setV1: %s", x);
        }
    }

    function setV1andV2(uint256 _v1, uint256 _v2) public {
        (bool success, bytes memory result) = _calleeAddr.delegatecall(
            abi.encodeWithSignature("setV1andV2(uint256,uint256)", _v1, _v2)
        );
        (uint256 x, uint256 y) = abi.decode(result, (uint256, uint256));
        console.log("setV1andV2: %s, %s", x, y);
    }

    function setTemplate(
        uint256 idx,
        uint256 _val1,
        uint256 _val2
    ) public {
        
        (bool success, bytes memory result) = _calleeAddr.delegatecall(
            abi.encodeWithSignature("setTemplate(uint256,(uint256,uint256))",idx,  _val1, _val2)
        );
        console.logBytes(result);
    }


    function getTemplate(uint256 _idx) public {
     

        (bool success, bytes memory result) = _calleeAddr.delegatecall(
            abi.encodeWithSignature("getTemplate(uint256)",_idx)
        );
        console.logBytes(result);

    }
}

2 가스비 차이

이걸알기 위해 이 모든 테스트를 시작했다

결과는 다음과 같다

Callee 에서 직접 js 로 부르기 <<<< Interface << delegate call < call

의외로 인터페이스로 부르는게 제일 효율적이었다

다음엔.. 꼭 이더리움 황서 읽는법을 익혀서 계산하고싶다.. 전수 테스트 말고

그러면 call, delegate call은 왜 존재하고 차이가 뭐길래 가스비가 차이가 나는걸까?

더 좋은점이 있어서 비싼것일까?

3 Low / High level function

call 과 delegate call 은 Low level function 이다.

(1)로우레벨 펑션이 뭐가 좋냐면 컨트랙트의 펑션을 dynamic하게 발동할수 있게한다.

이는 자바의 reflection 과 비슷한데,

자바의 reflection 이란 구체적인 클래스 타입을 알지 못해도 그 클래스의 메소드, 타입, 변수들에 접근할 수 있도록 한다.

간단한 코딩에서는 필요없지만 나중에 패턴을 도입하면 필요할수 있다.

이게 와닿는지 않는다면

(2) Low 는 실패시 무조건 revert 시키지 않고

성공결과가 bool 로 리턴된다. false를 리턴받으면 실패인것.

그래서 false 를 받았을때 재시도하기 등의 여러 작업을 해볼수있다.

4 최종 컨트랙트의 msg. sender, 데이터 저장위치

call, interface를 통한 호출의 경우에는 callee 를 부른 주소가 (msg.sender)

반면 delegate call 의 경우에는 callee를 부른주소가 최초의 eoa 이다.

Callee.sol 에 로그 추가해주고 각 caller의 setV1 에도 로그를 찍는다.

function setV1(uint256 _value1) external returns (uint256) {
        console.log('callee address: %s', msg.sender);
        
        value1 = _value1;
        return value1;
    }

이제 로그를 찍어보면

0xf39fd... 가 EOA 다.

맨처음 delegatecall의 경우 EOA 가 최종 컬리와 딜리게이트콜 컨트랙트를 모두 부름을 알수있다.

call, interface 의 경우 배포된 주소(CA)로 callee address를 부르게된다.

저장위치

delegate call 이용시 데이터는 Caller_delegateCall.sol 에 저장되고 Callee.sol 은 함수만 제공한다.

-> 이걸 upgradeble smart contract 라고함

solidity 에러 - stack too deep

_April — Wed, 24 Aug 2022 14:18:31 +0900

여러 기능을 넣는데 갑자기 이런 에러가 떴다.

"CompilerError: Stack too deep. Try compiling with `--via-ir` (cli) or the equivalent `viaIR: true`
... Otherwise, try removing local variables."

다행히 다들 겪는 일이었다

고통은 나누면 반이된다,,

에러의 이유

EVM 스택에는 16 variable 밖에 못올라간다. 이 variable 은 input and output arguments 모두를 포함한다-> 너무나 황당

정확히는 16슬랏이긴한데, 보통 1슬랏 1 variable 쓰니까....

이제 취향껏 고쳐보자

해결법

1. variable 갯수 줄이기 ㅋㅋ

2. internal function 쓰기 ( 실행 다 되면 메모리가 해제되니까 ㅇㅇ )

3. block scoping

4. struct 활용하기

예를들면 이런 문제코드가 있다. 이 코드를 1~4번방식으로 고쳐보자.

contract StackTooDeepTest {
    function addUints(
        uint256 a,uint256 b,uint256 c,uint256 d,uint256 e,uint256 f,uint256 g,uint256 h,uint256 i
    ) external pure returns(uint256) {
        
        return a+b+c+d+e+f+g+h+i;
    }
}

에러나는이유: 로컬변수가 너무많아서

-> 여기 이해가안감 로컬변수 a~i 까지 9개에 리턴시 1개 추가 해서 10개아닌가?

return 내의 객체가 하나씩 다르게 잡혀서 18개로 잡히나?

1. 이경우 variable 갯수를 더 줄일수 없다.

2. internal function 쓰기

contract StackTooDeepTest {
   function addUints(
        uint256 a,uint256 b,uint256 c,uint256 d,uint256 e,uint256 f,uint256 g,uint256 h,uint256 i
    ) external pure returns(uint256) {
        
        return _addThreeUints(a,b,c) + _addThreeUints(d,e,f) + _addThreeUints(g,h,i);
    }
    
    function _addThreeUints(uint256 a, uint256 b, uint256 c) private pure returns(uint256) {
        return a+b+c;
    }
}

이렇게 더하는 함수를 새로 만들면

a~i까지 9개에 리턴에 로컬변수 3개로 잡혀서 총 12개로 잡히는 것 같다.

기능따라 펑션을 분리하는 것은 좋은 습관이므로 좋은 코딩법에도 기여한다.

3. block scoping

uniswap 에서 쓴방법

contract StackTooDeepTest {
    function addUints(
        uint256 a,uint256 b,uint256 c,uint256 d,uint256 e,uint256 f,uint256 g,uint256 h,uint256 i
    ) external pure returns(uint256) {
        
        uint256 result = 0;
        
        {
            result = a+b+c+d+e;
        }
        
        {
            result = result+f+g+h+i;
        }

        return result;
    }
}

js 의 block scoping 과 같아보인다.

Block scoped variables: A block scoped variable means that the variable defined within a block will not be accessible from outside the block. A block can reside inside a function, and a block scoped variable will not be available outside the block even if the block is inside a function.

이러면 처음 로컬변수 9개

result 까지 10개

result = a+b+c+d+e; 때 총 15개

첫번째 block scope 가 끝나면 다시 10개

두번째 block scope 안에서 14개

두번째 scope 끝나면 다시 10개...

이런식으로 관리가 가능하다.

함수로 분리하기 애매할때 사용하면 좋아보임

4. Use Structs

객체를 쓰자 객체

contract StackTooDeepTest {
    struct UintPair {
        uint256 value1;
        uint256 value2;
    }
    
    function addUints(
        UintPair memory a, UintPair memory b, UintPair memory c, UintPair memory d, uint256 e
    ) external pure returns(uint256) {
        
        return a.value1+a.value2+b.value1+b.value2+c.value1+c.value2+d.value1+d.value2+e;
    }
}

a~i 까지 변수 9개가

변수 a~e 5개로 줄었다.

이게 작동한다는 것은 return 때도 객체가 struct 채로 메모리가 할당됨을 알수있다.

근데

이렇게 평화롭게끝나면

솔리디티가

아니지

만약 16 slot 변수까지 된다면..

이런코드도 되어야한다.

contract TestStackError {

  event LogValue(uint);

  function logArg(
    uint a1, uint a2, uint a3, uint a4,
    uint a5, uint a6, uint a7, uint a8,
    uint a9, uint a10, uint a11, uint a12,
    uint a13, uint a14, uint a15, uint a16
  ) public {
    emit LogValue(a16);
  }
}

인풋 아규먼트가 16개잖아

되야맞다 ㅇㅇ

근데 결과는?

ptsd 담당

한참찾아보니

이게 오랜 에러였고

솔리디티 버전 0.8.13 부터 IR 파이프라인을 개선함으로서 고쳤다고 주장했다.

출처1 출처2

고쳤다고 하니 실제로 옵션을 바꾸라는대로 바꿔보자.

빌드 고고고

안돼

이 에러 6월에 고치고있었잖아.. 이후에 솔리디티 버전도 업데이트 됐잖아.. 왜 이 에러는 아직도 fix 가 안됐어..?

하여튼 에러고쳐질때까지 16개 slot 꽉채워 못쓴다가 결론이다

출처

https://soliditydeveloper.com/stacktoodeep

https://medium.com/coinmonks/stack-too-deep-error-in-solidity-608d1bd6a1ea

[Solidity]String 과 용량, 가스비

_April — Fri, 29 Jul 2022 17:00:37 +0900

가스비를 계산하는데 뭔가 계속 이상했다.

https://realapril.tistory.com/112

Storing Structs is costing you gas

Storing Structs is costing you gas 라는 글을 보고 가스를 측정해 보았다. 2018년 글 wow 여러 시나리오가 테스트되어있다. 가스비가 그냥 state 여러개 저장 >>>construct > construct 내 변수 최적화>>+알파 ..

realapril.tistory.com

에 따르면

    struct A{
        address sideWallet1;
        address sideWallet2;
        address sideWallet3;
    }

    struct B {
        string cid;
    }

struct 하나를 저장할때 struct A가스비가 struct B 보다 비싸야한다고 생각했다.

이유는 address 는 하나당 20 바이트이므로 저장할 때 slot 3개를 사용하기때문이다. (1 slot = 32 바이트)

반면 내 cid 는 46바이트인데, 저장하는데 slot 2개가 필요하기 때문이다.

그런데 로그를 찍어보면 저장할때 소모되는 가스비가 거의 비슷했다.

왜..? 왜???

열심히 검색해본결과 "정상"이다.

https://ethereum.stackexchange.com/questions/107282/storage-and-memory-layout-of-strings

Storage and memory layout of strings

How exactly are strings stored in storage? And, how does that differ from the way they're stored in memory when loaded from storage into a memory variable?

ethereum.stackexchange.com

bytes and string are encoded identically. In general, the encoding is similar to bytes1[], in the sense that there is a slot for the array itself and a data area that is computed using a keccak256 hash of that slot’s position. However, for short values (shorter than 32 bytes) the array elements are stored together with the length in the same slot.

In particular: if the data is at most 31 bytes long, the elements are stored in the higher-order bytes (left aligned) and the lowest-order byte stores the value length * 2. For byte arrays that store data which is 32 or more bytes long, the main slot p stores length * 2 + 1 and the data is stored as usual in keccak256(p). This means that you can distinguish a short array from a long array by checking if the lowest bit is set: short (not set) and long (set).

So for example a string "abcd" will use the short format and take up a single slot with the upper four bytes being characters a, b, c, d and remaining bytes being zeros.

On the other hand "0123456789012345678901234567890123456789", which has more than 32 characters will take 3 slots. A single slot placed at the normal location between other storage variables will only contain the length (40) shifted left by one bit and will have the last bit set to indicate that it's the long format. I.e. its value will be 81. The other two slots will store the characters of the string (with unused space being filled with zeros) and the compiler will place them at a location computed by hashing the address of the slot containing length with keccak256().

예를 들어 문자열 "abcd"는 짧은 형식을 사용하고 상위 4바이트는 문자 a, b, c, d이고 나머지 바이트는 0인 단일 슬롯을 차지합니다.

반면 32자 이상인 "0123456789012345678901234567890123456789"는 3슬롯을 차지한다. 다른 저장 변수 사이의 일반 위치에 있는 단일 슬롯은 왼쪽으로 1비트 이동한 길이(40)만 포함하고 마지막 비트가 긴 형식임을 나타내기 위해 설정됩니다. 즉. 값은 81이 됩니다. 다른 두 슬롯은 문자열의 문자를 저장하고(사용하지 않은 공간은 0으로 채워짐) 컴파일러는 keccak256()으로 길이를 포함하는 슬롯의 주소를 해싱하여 계산된 위치에 배치합니다.

= 첫 슬롯은 길이(40글자 짜리다)와 긴 스트링 양식이다 라는 정보값만 저장하고, 나머지 2 슬롯 에 실제 데이터가 나누어져서 저장된다.

또 더나아가서, string 을 불러올때는 메모리를 자주 사용한다. 근데,, 내가 생각하는것과 용량이 다르다.

In memory "abcd" will occupy two consecutive 32-byte slots. The first will store the length and the other the characters.

"0123456789012345678901234567890123456789" will occupy 3 consecutive slots with the first containing the length (40) and the other two storing the characters. There's no short/long format in memory so the length is not shifted like it would be in storage.

놀라운걸

opensea 및 NFT market 매매 흐름(setApprovalForAll, safeTransferFrom)

_April — Fri, 22 Jul 2022 17:27:30 +0900

1. 매도자가 매도 신청을함.

오픈씨는 이때 setApprovalForAll 에 대한 허가를 매도자에게 받음

https://etherscan.io/tx/0x89b6b30c30f05a56daeb1d499ce8e57ffec1522cc9cfdf138453154066a316c5

Ethereum Transaction Hash (Txhash) Details | Etherscan

Ethereum (ETH) detailed transaction info for txhash 0x89b6b30c30f05a56daeb1d499ce8e57ffec1522cc9cfdf138453154066a316c5. The transaction status, block confirmation, gas fee, Ether (ETH), and token transfer are shown.

etherscan.io

2. 시간이 지나 매수자가 매수 신청을함.

이때 opensea의 Seaport contract와 상호작용을 하게된다. opensea에 이더리움을 보내고, 수수료를 떼고, 대금을 매도자에게 보내는것을 볼 수 있다.

대금지불이 완료되면 오픈씨는 Transfer() 함수를 통해 매도자의 NFT 를 매수자에게 보낸다.

리스팅을 올렸다고 NFT를 오픈씨가 가져가거나 사용을 제한하지 않는다

setApprovalForAll 하나만 활성화할뿐..

오픈씨에 등록이 되어있는건 그냥 웹2.0적인 리스팅이기 때문에

매도자는 그 NFT를 팔겠다고 해놓고 실제로는 burn 할수도있고 transfer 도 할수있다.

물론 이런 invalid 한 NFT 는 매수시 당연히 실패할것이고,

오픈씨가 서버상황이 원활하다면 금방 매도 리스팅에서 제거되기 때문에

실제로 큰문제는 생기지 않는다.

https://etherscan.io/tx/0x7110f12c3a13f039affb946b14c29c4b0b3a44c8689278f6885c5f30f2b0791b

Ethereum Transaction Hash (Txhash) Details | Etherscan

Ethereum (ETH) detailed transaction info for txhash 0x7110f12c3a13f039affb946b14c29c4b0b3a44c8689278f6885c5f30f2b0791b. The transaction status, block confirmation, gas fee, Ether (ETH), and token transfer are shown.

etherscan.io

트랜젝션을 일으킨것은 매수자이므로 매수자의 지갑에 nonce 가 생성된다.(Nonce: 2455)

정리해보니 단순한데 이해하기 힘들었음..

Storing Structs is costing you gas

_April — Mon, 20 Jun 2022 23:35:50 +0900

Storing Structs is costing you gas 라는 글을 보고 가스를 측정해 보았다.

2018년 글 wow

여러 시나리오가 테스트되어있다.

가스비가 그냥 state 여러개 저장 >>>construct > construct 내 변수 최적화>>+알파 순으로 든다는 주장인데,

직접 실험해보았다.

In Solidity (the programming language used for Ethereum smart contracts), you have “memory”, (think RAM on a computer), and “storage” (think the hard drive). Both are set up in chunks of 32 bytes (a byte is roughly a letter, so “are set up in chunks of 32 bytes” is 32 bytes of data).
In Solidity, memory is inexpensive (3 gas to store or update a value).
Storage is expensive (20,000 gas to store a value, 5,000 gas to update one). -> SSTORE

시나리오 1 - struct 아예 사용 안함

//Type1
    address owner;
    uint64 creationTime;
    uint256 dna;
    uint16 strength;
    uint16 race;
    uint16 class;
    mapping(uint256 => address) owners;
    mapping(uint256 => uint64) creationTimes;
    mapping(uint256 => uint256) dnas;
    mapping(uint256 => uint16) strengths;
    mapping(uint256 => uint16) races;
    mapping(uint256 => uint16) classes;

    function save1(
        uint64 _creationTime,
        uint256 _dna,
        uint16 _strength,
        uint16 _race,
        uint16 _class
    ) external {
        owners[dna] = msg.sender;
        creationTimes[dna] = _creationTime;
        dnas[dna] = _dna;
        strengths[dna] = _strength;
        races[dna] = _race;
        classes[dna] = _class;
    }

이제 ts에서 테스트해보자

it("Should success1 - gas test", async function () {
    const tx = await gasTest
      .connect(account1)
      .save1(Date.now(), 123123, 8, 0, 3);
    const receipt = await tx.wait();
    console.log(receipt.gasUsed);
  });

결과 : BigNumber { value: "139052" }

시나리오 1 - struct 사용

//Type 2
    struct GameCharacter2 {
        address owner;
        uint64 creationTime;
        uint256 dna;
        uint16 strength;
        uint16 race;
        uint16 class;
    }
    mapping(uint256 => GameCharacter2) characters2;

    function save2(
        uint64 _creationTime,
        uint256 _dna,
        uint16 _strength,
        uint16 _race,
        uint16 _class
    ) external {
        characters2[_dna] = GameCharacter2({
            owner: msg.sender,
            creationTime: _creationTime,
            dna: _dna,
            strength: _strength,
            race: _race,
            class: _class
        });
    }

이제 테스트할차례

it("Should success2 - gas test", async function () {
    const tx = await gasTest
      .connect(account1)
      .save2(Date.now(), 123123, 8, 0, 3);
    const receipt = await tx.wait();
    console.log(receipt.gasUsed);
  });

결과 : BigNumber { value: "90709" }

진짜 가스가 줄었다.

시나리오 1에서는 스토리지에 저장이 6번이루어졌으므로 120,000가스가 들것이다. (실제로는 139052)

시나리오 2에서는 슬롯이 줄어들어 75,000 gas가 든다. (왜 80000이 아니고 75000인지모르겠음 )

연달아 나오는 데이터가 32바이트가안되면 컴파일러가 알아서 합쳐서 패키징한다.

owner, creationTime을 같은 슬랏에 패키징하고, dna는 따로, strength, race, and class도 같은 슬랏에 패키징한다.

시나리오3 - 패키징 용량을 더 줄여보자

 //Type3
    struct GameCharacter3 {
        address owner;
        uint48 creationTime;
        uint16 strength;
        uint16 race;
        uint16 class;
        uint256 dna;
    }
    mapping(uint256 => GameCharacter3) characters3;

    function save3(
        uint48 _creationTime,
        uint256 _dna,
        uint16 _strength,
        uint16 _race,
        uint16 _class
    ) external {
        characters3[_dna] = GameCharacter3({
            owner: msg.sender,
            creationTime: _creationTime,
            dna: _dna,
            strength: _strength,
            race: _race,
            class: _class
        });
    }

두가지변화가있는데, 시간의 데이터타입이 uint48이 되었고 dna는 맨끝으로 옮겼다.

uint 의 크기는 꼭 8, 16, 64 가 아니라 그냥 8의 배수기만하면된다.

이렇게 하면 장점은

owner~class 까지 모두 하나의 32바이트 청크에 저장이된다. (20+6+2+2+2)

uint256 인 dna 는 이미 혼자 32바이트 청크를 차지한다.

이제 저장에 60,000 gas만든다. (owner~class, dna, 맵저장인듯)

실제로 ts 에서 돌려보면

BigNumber { value: "68837" }
많이줄었다.

마지막방식은 들이는 공수에비해 가스비가 그렇게 줄지않았다.

그리고 40000가스가 든다고하는데,

캐릭터가 1슬랏을 차지하고 characters 맵과 dnaRecords맵에 저장할때 각각 슬랏을 하나씩 차지해서 결국 비슷하게 들지않나?

실제로 테스트결과

BigNumber { value: "68364" }로 유의미하게 감소하지 않았다... 뭔가 바뀐걸까

//Type4
    struct GameCharacter4 {
        address owner;
        uint256 creationTime;
        uint256 strength;
        uint256 race;
        uint256 class;
        uint256 dna;
    }

    mapping(uint256 => uint256) characters4;
    mapping(uint256 => uint256) dnaRecords4;

    function setCharacter(
        uint256 _id,
        address owner,
        uint256 creationTime,
        uint256 strength,
        uint256 race,
        uint256 class,
        uint256 dna
    ) external {
        uint256 character = uint256(uint160(owner));
        character |= creationTime << 160;
        character |= strength << 208;
        character |= race << 224;
        character |= class << 240;
        characters4[_id] = character;
        dnaRecords4[_id] = dna;
    }

    function getCharacter(uint256 _id)
        external
        view
        returns (
            address owner,
            uint256 creationTime,
            uint256 strength,
            uint256 race,
            uint256 class,
            uint256 dna
        )
    {
        uint256 character = characters4[_id];
        dna = dnaRecords4[_id];
        owner = address(uint160(character)); 
        creationTime = uint256(uint40(character >> 160));
        strength = uint256(uint16(character >> 208));
        race = uint256(uint16(character >> 224));
        class = uint256(uint16(character >> 240));
    }

기본요지는 어차피 uint256가 하나의 슬랏을 차지하니까

그 안에 메모리 위치를 지정헤서 데이터를 다 넣어버리자는거다.

it("Should success4 - gas test", async function () {
    const tx = await gasTest
      .connect(account1)
      .setCharacter(0, account1.getAddress(), Date.now(), 8, 0, 3, 123123);
    const receipt = await tx.wait();
    console.log(receipt.gasUsed);
  });

별로 안주는데 왜 블로그글에서는 많이 주는척했는지?

쓰고 읽을때 예외처리까지 해야해서 작성시 생산성도 떨어지는데 왜 과시하는지?

나를 이해시켜줄분 구함

코드는

https://gist.github.com/crypt0summer/7aeae440e5592edbd43d23ea688591fe

Ethreum-Storing Structs is costing you gas

Ethreum-Storing Structs is costing you gas. GitHub Gist: instantly share code, notes, and snippets.

gist.github.com

에있다.

interact with existing deployed contracts, raw calls

_April — Thu, 16 Jun 2022 19:30:19 +0900

외부 컨트랙트를 부를때

이렇게 인터페이스로 부르는 방식이 있고

//1
interface IVault {
    function createVault(uint256 gameId) external payable;
    function addAmount(uint256 gameId) external payable;
    function withdraw(uint256 gameId, address payable winner) external payable;
    function claim(uint256 gameId, address payable user) external payable;
}
//2
address vaultAddr;
//3
    function setVault(address _vaultAddr) external {
        vaultAddr = _vaultAddr;
    }
//4
...
	IVault(vaultAddr).addAmount{value: msg.value}(gameId);
...

ABI 로 부르는 방식이 있다.

import "./Vault.sol"; //외부컨트랙트 abi 불러옴

address vaultContract;

function setVault(address vaultAddr) external {
        vaultContract = vaultAddr;
    }
    
    ...
    
    (bool success, ) = vaultContract.call{value: msg.value}(
            abi.encodeWithSignature("createVault(uint256)", gameId)
        );
        require(success, "Failed to createVault vault");
        
    ...

나는 인터페이스 작성하기가 귀찮아서ㅠ ABI 로 불렀는데..

생각해보니 ABI 로 콜함으로서 전부 raw call로 함수를 불렀어야했다.

걍

IVault(vaultAddr).addAmount{value: msg.value}(gameId);

라고 쓰면될걸

(bool success, ) = vaultAddr.call{value: msg.value}(

abi.encodeWithSignature("addAmount(uint256)", gameId)

);

require(success, "Failed to addAmount vault");

라고 써야해서

결과적으로는 남이 코드를 읽기 더어렵게 만들었을 뿐...

그럼 raw call 은 언제 쓰는가?

consensys 베스트 프랙티스에 따르면

It's recommended to stop using .transfer() and .send() and instead use .call().

송금 시 raw call을 쓰라고한다.

One of the changes included in EIP 1884 is an increase to the gas cost of the
SLOAD operation, causing a contract's fallback function to cost more than 2300 gas.

.transfer() and .send() 은 2300 가스로 픽스가되어있어 이스탄불 업데이트 이후 (2019) 해당 펑션 이용시 가스비가 부족하기 때문이다.

아니 근데, 예제는 transfer 이나 send 하는 상황이아니잖아? raw call 의 이점이 뭐냐니까?

Raw call 의 이점: 에러 핸들링

address.call을 하면 성공/실패 여부를 bool로 받을수 있다.

실패시 내가 케이스 관리를 해야한다/할수있다.

// good
(bool success, ) = someAddress.call.value(55)("");
if(!success) {
    // handle failure code
}

컨트랙트.function() 도 당연히 성공, 실패 여부를 알수 있지만 실패시 throw an exception이어서 다음 코드가 실행되지 않는다.

내가 실패 케이스를 따로 관리(재시도를 한다거나)하는 시나리오가 아니라면

컨트랙트.function() 를 사용하는게 나을수 있다.

일단 심플하다

그리고 raw call을 하던 contract.call을 하던 외부 컨트랙트를 부를 때 더 신경써야하는 부분이 있다.

이 코드는 옥션 입찰에 상위입찰이 들어오면 그 전의 1등에게 출금을 해주려한다.

// bad
contract auction {
    address highestBidder;
    uint highestBid;

    function bid() payable {
        require(msg.value >= highestBid);

        if (highestBidder != address(0)) {
            (bool success, ) = highestBidder.call.value(highestBid)("");
            require(success); // if this call consistently fails, no one else can bid
        }

       highestBidder = msg.sender;
       highestBid = msg.value;
    }
}

근데 외부 컨트랙트에서 실패가 뜨면, require(success); 에 막혀서 bid()함수 자체가 작동하지 않게된다.

내 컨트랙트 탓이 아닌 외부 컨트랙트의 상태에 따라 좌지우지되는것.

외부 컨트랙트를 부르는 기능을 분리하자.

// good
contract auction {
    address highestBidder;
    uint highestBid;
    mapping(address => uint) refunds;

    function bid() payable external {
        require(msg.value >= highestBid);

        if (highestBidder != address(0)) {
            refunds[highestBidder] += highestBid; // record the refund that this user can claim
        }

        highestBidder = msg.sender;
        highestBid = msg.value;
    }

    function withdrawRefund() external {
        uint refund = refunds[msg.sender];
        refunds[msg.sender] = 0;
        (bool success, ) = msg.sender.call.value(refund)("");
        require(success);
    }
}

상위입찰자가 갱신되면 매핑에 환불할 지갑과 주소를 저장하고,

예전 입찰자들이 withdrawRefund()로 환불을 요청하면 그때 외부 함수를 부르는식이다.

이러면 외부 컨트랙트에 문제가 생겨도 입찰함수는 영향을 받지않고 출금함수만 영향을 받는다.

이러면 UI 단에 출금버튼이 하나 더생겨야한다. 기존에는 신청 안하고 가만히 있어도 알아서지갑에 환불되는방식이었음.

이미지화하면 이런식이다. (딱맞진않음 그냥 add claim 분리한다는의미)

(근데 withdrawRefund() 내에 refund금액이 0인지 확인안하고 그냥 송금해도되나?

하긴 다른 컨트랙트에서 예외처리해놨을수도)

다만 이렇게하면 가스비가 추가로든다

심지어 매핑에 저장하는것은 스토리지 저장이어서 비싸다. 저장에(SSTORE) 대략 20,000 gas, 업데이트에 5,000 gas

그니까 외부 컨트랙트를 부른다고 전부 매핑으로 저장하는게 아니고 돈과 관련된 필수 기능만 매핑해서 저장하는게 옳아보인다.

가스비

20000 per 32 bytes with an overhead of 20000 for the length.
Plus 68 gas per byte (2176 gas per 32 bytes) for storing the calldata

Hardhat vs Truffle

_April — Thu, 2 Jun 2022 05:07:15 +0900

하드햇과 트러플은 모두 블록체인, 이더리움을 개발할때 환경설정을 도와주는 툴이다.

구체적으로는 테스트 노드의 EVM에서 스마트컨트랙트를 compile, run, test 하는과정을 도와준다.

둘다 Javascript 기반 환경을 제공하는데, 예전 튜토리얼을 보면 대부분 트러플을 추천하는데

요새 튜토리얼은 대부분 하드햇을 추천한다.

어떤 차이와 장단점이 있는지 정리해보려한다.

Remix도 좋은 툴이지만 둘과는 완전히 맥락이 다르므로 이번에는 패스.

Github

Hardhat

3.3k stars, 마지막 업데이트 1시간 전

Truffle

13.2k stars, 마지막 업데이트 1달 전

이것만보면 하드햇을 쓰는건 모험처럼 보일수도 있다.

Solidity2021 survey

2020년엔 분명 하드햇-트러플 유저가 반반이었는데

하드햇유저수가 트러플을 완전히 추월해버렸다.

제작사

Hardhat

Nomics Labs에서 만들었다. 여기도 계속 개발할 사람을 고용중인것을 보니 팀의 상황은 좋아보인다.

Truffle

Metamask로도 유명하고, 이번에 텍사스 컨센시스 행사를 여는 그 Consensys 사가 만들었다.

정확히는 만든게아니라 트러플팀을 인수한건데, 2020년에 인수해서 계속 트러플을 개선할 인력을 고용중이다.

Ganache라는 스마트컨트랙트를 테스트용 로컬 이더리움 블록체인을 제공한다.

문서

하드햇문서는 심플하고 명료하고 잘된다. 특히 튜토리얼 문서를 따로 제공하는데, 정말 고맙다.

트러플문서도 꼼꼼하게 잘나와있다. 그런데 아마 한번 장벽에 부딪힐텐데,

가나슈를 이용해 로컬 이더리움 네트워크를 환경설정 세팅하는 예제가 기본예제이기 때문이다.

처음 컨트랙트를 개발하는사람한테는 좀 어려운 개념이다.

대부분의 초보 개발자는 로컬 이더리움 네트워크 / 가나슈를 돌리기 원하지않는다.

엔드포인트를 Infura나 alchemy걸 쓰지.

그런데 트러플은 기본설정을 가나슈로 잡아버리면서

module.exports = {
  // See <http://truffleframework.com/docs/advanced/configuration>
  // for more about customizing your Truffle configuration!
  networks: {
    development: {
      host: "127.0.0.1",
      port: 7545,
      network_id: "*" // Match any network id
    },
    develop: {
      port: 8545
    }
  }
};

이렇게 디폴트로 로컬연결 정보를 제공하기때문에 초보 개발자들은 혼란스러워하다가

하드햇으로 탈주해버린다.

생태계 유지도 좋지만 옵션으로 둬야지(알케미나나 인푸라 연결문서도 병기했어야한다고봄)

모든문서에서 가나슈 원툴을 강권하면 겁먹은 초보개발자들이 이탈한다고요~!

하드햇에서는 설정이 없을시 하드햇자체 이더리움 네트워크를 기본으로 제공하기때문에

더욱 대비되는 부분이다.

커뮤니티

둘다 Stackoverflow 나 Stackexchange 에서 물어보는게 보통이고,

아니면 깃허브에 가서 이슈나 커뮤니티탭에 가면 대답을 잘해준다.

Hardhat 은 커뮤니티탭만 지원하고 (이슈는 정말 업무정리용으로만 사용)

Truffle 은 깃허브의 모든탭이 오픈되어있다. 따로 커뮤니티도 운영했던것 같은데 깃허브로 통합됨.

개인적으로 커뮤니티탭만 지원하는 곳은 소통이 덜된다 느낀적이 많긴한데

그래도 문제는 결국 다 해결되곤 했기에...

트러플이 더 오래되어서 그런가 커뮤니티는 좀더 잘되어있는 느낌이다.

테스트

Hardhat

주로 Ethers.js + Waffle(Mocha&chai) 조합을 쓴다. 당연히 Ethers.js 대신 web3.js를 써도 된다.

Truffle

주로 web3.js + Waffle(Mocha&chai) 조합을 쓴다.

Library

하드햇은 여러 라이브러리를 제공한다

HRE - Hardhat Runtime Environment

하드햇 네트워크 위에서 작동하는 web3 object를 제공한다.

web3 object 은 blockchain과 상호작용하려면 필요한데,

hre 위에서 쉽게 Ethers.js 나 web3.js 를 부를수있다.

import { ethers, web3 } from "hardhat";

또한 하드햇에서는 컨트랙트 내에서도 console.log 를 찍을수 있다!! (하드햇 자체 네트워크만 지원함)

+이뿐만이 아니라 하드햇에서는 바로 이더스캔에 verify 가 가능하다.

+hardhat 플러그인인 Typechain을 이용해서 타입스크립트사용도 편하다.

기본 파일

하드햇은 만들면 바로 왼쪽같이 기본컨트랙트, 배포 스크립트, 테스트폴더와 파일이 생긴다.

트러플은 빈파일이 생기기 때문에 튜토리얼에 나온대로 truffle box 를 사용해 권장 예제를 받아왔다.

하드햇과 비슷한 모양새이다.

migration이 script 와 같은 역할, 즉 deploy기능을 한다.

뭘써도 상관없지만 민심은 하드햇으로 기운듯 하다.

하드햇 = 트러플+가나슈 라고 추천하는 곳도 있다

지금부터 배운다면 하드햇을 선택하는게 더 편하지 않을까 싶다.

로컬이더리움 안돌리고 하드햇 이더리움 네트워크를 무노력으로 쓸수있다니 너무나 꿀인것.

외전

개인적으로 트러플이 비호감인 이유

구글링하면 자꾸 요리법이 나온다..

이름을 잘못지었다ㅠㅠ 구글링이 너무 힘들다.

하드햇보다 더 힘들다

deploying contract, Compiler specific version warnings

_April — Fri, 20 May 2022 00:27:21 +0900

첫 NFT 를 이더리움 메인넷에 배포했다.

다행히 코인값도 떨어지고 가스비도 낮아서(15그웨이 고맙다)

적은부담으로 할수 있었다.

컨트랙트도 올리고 민팅도 잘되고

디자인도 이쁘게 나오고

이더스캔에도 컨트랙도 잘 올렸는데

이게 뭐람?

느낌표가 있길래 눌러봤더니

가능한 버그가 세개나? 이럴수가

열심히 디버깅한다고 했는데 이런 참사가..

싶어서 3개를 들여다 보았다.

다행히 very low-severity 라고 떠서 사소하긴하지만 신경쓰이잖아.

(1)DataLocationChangeInInternalOverride

(2)NestedCallataArrayAbiReencodingSizeValidation

(3)SignedImmutables

3종류가 떴다.

혹시나하고 다른 nft 프로젝트의 컨트랙트를봤는데

안-심

낮은 심각성의 warning 은 괜찮은듯 하다.

심지어 2종류는 나와 같다. 나는 (3)사인드이뮤터블즈가 더 있고

그래도 간략하게 맛보기를해보면

(1)DataLocationChangeInInternalOverride

It was possible to change the data location of the parameters or return variables from ``calldata`` to ``memory`` and vice- versa while overriding internal and public functions.

This caused invalid code to be generated when calling such a function internally through virtual function calls.

어렵다. 더 긴설명을 보자...

외부 함수를 호출할 때 매개 변수의 데이터 위치가 "call data" 또는 "memory"인 경우 데이터의 인코딩은 변경되지 않습니다. 따라서 외부 기능을 재정의할 때 데이터 위치를 변경할 수 있습니다. 컴파일러는 또한 공개 및 내부 함수를 재정의하기 위해 데이터 위치의 변경을 잘못 허용하였다. 공용 함수는 내부뿐만 아니라 외부에서도 호출될 수 있기 때문에, 이렇게 잘못 재정의된 함수가 기본 계약을 통해 내부적으로 호출될 때 유효하지 않은 코드가 생성된다. 호출자는 메모리 포인터를 제공하지만 호출된 함수는 호출 데이터 포인터로 해석하거나 그 반대로 해석한다.

먼소리고? 하고 예시를봤다.

https://blog.soliditylang.org/2022/05/17/data-location-inheritance-bug/

Bug Concerning Data Location during Inheritance

On February 5th 2021, Nicolas Venturo reported a bug that allows overriding functions to change the data location of parameters from memory to calldata. The bug was introduced in Solidity 0.6.9 together with the ability to use calldata data location for al

blog.soliditylang.org

abstract contract I {
    // The base contract uses "calldata"
    function f(uint[] calldata x) virtual internal;
}
contract C is I {
    // The derived contract uses "memory" and the compiler
    // does not complain - this is the bug in the compiler.
    function f(uint[] memory x)  override internal {
        // If you use `x`, it will access memory
        // even if `D.g` passed us a calldata pointer.
        // This leads to the wrong data being accessed.
    }
}
abstract contract D is I {
    function g(uint[] calldata x)  external {
        // Since D only "knows" `I`, the signature of `f`
        // uses calldata, while the virtual lookup ends
        // up with `C.f`, which uses memory. This results
        // in the calldata pointer `x` being passed and
        // interpreted as a memory pointer.
        f(x);
    }
}
contract X is C, D { }

이경우 C 가 잘못된 오버라이드를 했는데,

잘못된 C 를 extend 한 X 도 해당 에러가 난다.

나의경우 상속을 하지 않았기때문에.. C 처럼 잘못된 오버라이드를 했을거란 생각이 들었다.

    function _baseURI() internal view virtual override returns (string memory) {
        return _baseTokenURI;
    }

내경우 오버라이드가 이뤄진 펑션은 이거 하나뿐이었는데,

openzeplin ERC721.sol 에 들어가서 오리지널을보았더니

 function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

같은데..?

의문이다.

(2)NestedCallataArrayAbiReencodingSizeValidation

ABI-re encoding of nested dynamic calldata arrays did not always perform

proper size checks against the size of calldata and could read beyond ``calldatasize()``.

https://blog.soliditylang.org/2022/05/17/calldata-reencode-size-check-bug/

You might be affected if you pass a nested array directly to another external function call or use abi.encode on it.

원인: merkleProof 변수가 nested array 형태인데 그걸 그대로 external function call 에서 불러서..

머클트리는 양보 못한다. 패스 ㅠ

(3)SignedImmutables

Immutable variables of signed integer type shorter than 256 bits can lead to values with invalid higher order bits if inline assembly is used.

https://blog.soliditylang.org/2021/09/29/signed-immutables-bug/

황당하다.. 256보다 짧은 사인드 인티저를 써서 문제가되었다.

왜 일어났는가?: So the only way (to our knowledge) to obtain the “unclean” value of the immutable is to first assign it to a local variable and then read from that local variable inside inline assembly.

내경우엔 어샘블리를 딱히 쓰지않았기때문에 이것도 미스테리

내생각엔 rinkeby 테스트넷에도 verify 를 했다면 이 버그들이 나왔을거라고 본다.

디플로이 전 verify 하는 습관을 들이자

Merkle Tree - 솔리디티 화이트리스트 관리하기

_April — Sun, 24 Apr 2022 14:28:29 +0900

NFT 민팅할때 보통 화이트리스트에게 먼저 NFT를 민팅할 권리를 준다.

솔리디티에서 이부분을 구현할때

메모리나 맵에 올리면

가스비로 아주 큰 비용을 지불해야한다.

이 문제를 해결하는것이 머클트리이다

Merkle Tree

사용법

https://medium.com/@ItsCuzzo/using-merkle-trees-for-nft-whitelists-523b58ada3f9

간략하게말하면

js단:

(1) WL 리스트를 암호화해서(keccak256쓰던 SHA쓰던 본인선택) 머클트리에 넣는다.

그럼 암호화된 전체 노드가 나오는데 Root Node만 키처럼 들고있음

        const leaves = whitelistAddresses.map(addr => keccak256(addr));
        tree = new MerkleTree(leaves, keccak256, { sort: true });
        const root_merkle = tree.getRoot();

(2) 실제로 민팅할때는 주소를 암호화한 값을 머클트리에 넣었을때 proof값을 받아서,

컨트랙트로 보낸다.

        const hexProof = tree.getHexProof(keccak256(addr1.address));
        // console.log('hex: '+hexProof.toString());
        await nft_contract.connect(addr1).whitelistMint(hexProof);

솔리디티:

Root Node의 값과 머클트리 proof 값, 그리고 지갑주소값이 필요하다

MerkleProof 라이브러리로 두 값이 verify되는지 확인한다.

contract Merkle is Ownable{
    bytes32 public merkleRoot;

    mapping(address => bool) public whitelistClaimed;

    function whitelistMint(bytes32[] calldata _merkleProof) external{
        require(!whitelistClaimed[msg.sender], "Address has already claimed.");

        bytes32 leaf = keccak256(abi.encodePacked(msg.sender));

        //Verify the provided _merkleProof
        require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "Invalid Proof, No WL");

        whitelistClaimed[msg.sender] = true;

        //실제민팅하는곳
    }


    function setMerkleRoot(bytes32 _merkleRoot) public {
        merkleRoot = _merkleRoot;
    }

}

꼭 이런순서로 짤 필요는 없지만

어떤 구성요소가 필요한지 보고 시작하면 편하다

Storage, Memory and Calldata

_April — Sun, 27 Mar 2022 03:57:44 +0900

Variables are declared as either storage, memory or calldata to explicitly specify the location of the data.

storage - variable is a state variable (store on blockchain)
memory - variable is in memory and it exists while a function is being called
calldata - special data location that contains function arguments

-스토리지가 당연히 가스비가 제일 많이든다.

-메모리

이때 말하는 메모리는 evm의 메모리

https://ethereum.org/en/developers/docs/evm/#evm-instructions

During execution, the EVM maintains a transient memory (as a word-addressed byte array), which does not persist between transactions.

evm이 실행되면 임시메모리를 유지한다. 이 메모리는 임시이기 때문에 트젝간 유지/공유되지 않는다.

-calldata

The Calldata is a read-only byte-addressable space where the data parameter of a transaction or call is held

데이터 파라미터 = 아규먼트

calldata is where data from external calls to functions is stored.

When such an external call happens, the data of that call is stored in calldata.

https://docs.soliditylang.org/en/v0.8.13/types.html#data-location

모든 복합 타입은 자신이 메모리 나 스토리지 중 어디에 저장되었는지를 나타내는 "데이터 위치"가 추가적으로 존재합니다.

Calldata is a non-modifiable, non-persistent area where function arguments are stored,

and behaves mostly like memory.

✅If you can, try to use calldata as data location because it will avoid copies

and also makes sure that the data cannot be modified.

Arrays and structs with calldata data location can also be returned from functions,

but it is not possible to allocate such types.

가능하면 콜데이터를 써라. 카피를 피하고, 데이터 변경을 막기 때문임

->콜데이터 타입의 어레이와 스트럭(데이터) 는 펑션으로부터 리턴될수 있다.

그러나 그런타입을 할당할 수 없다...? 무슨말이지..?

✅Prior to version 0.6.9 data location for reference-type arguments was limited to calldata in external functions, memory in public functions and either memory or storage in internal and private ones. Now memory and calldata are allowed in all functions regardless of their visibility.

옛날엔 콜데이터와 메모리, 스토리지의 사용처가 엄격하게 제한되었다.

이제는 콜데이터와 메모리를 모든 visibility 상관없이 모든 펑션에서 쓸수있다.

✅Prior to version 0.5.0 the data location could be omitted, and would default to different locations depending on the kind of variable, function type, etc., but all complex types must now give an explicit data location.

옛날엔 데이터 로케이션 지정을 안해도 됐다.

변수 종류/ 펑션 타입따라 기본 로케이션이 있었기 때문이었음

그러나 모든 컴플렉스타입은 data location 을 꼭 지정해야함

Complex types, i.e. types which do not always fit into 256 bits have to be handled more carefully than the value-types we have already seen.

솔리디티 기본 데이터타입(bool, integer, comparison 이런거..) 말고

Arrays
Structs
Mapping

이런거의 경우 꼭 지정하라는말임

데이터 위치와 assignment(배치)행위

데이터 위치설정은 -데이터의 지속성, -할당의 의미 와 관계가 있다.

Assignments between storage and memory (or from calldata) always create an independent copy.
Assignments from memory to memory only create references.
This means that changes to one memory variable are also visible in all other memory variables
that refer to the same data.
Assignments from storage to a local storage variable also only assign a reference.
All other assignments to storage always copy.
Examples for this case are assignments to state variables or
to members of local variables of storage struct type, even if the local variable itself is just a reference.

전역변수는 무조건 스토리지에 저장됨. 데이터 로케이션 생략 가능

Assignments between storage and memory (or from calldata) always create an independent copy.

스토리지-메모리(콜데이터)간 배치는 무조건 독립된 카피를 야기한다.

-스토리지데이터 x= 메모리어레이 줄에서 어레이의 카피가 일어남

Assignments from memory to memory only create references.
This means that changes to one memory variable are also visible in all other memory variables
that refer to the same data.

메모리-메모리간 assignment는 레퍼런스만 만든다. (포인터를 지정해서 메모리 참조만 한다는 뜻인듯)

그래서 한쪽 메모리할당된 값을 변경하면 다른쪽에서도 변경된 값을 볼수있음

- 예시가 좀 이상함.. 메모리- 메모리 간이라고 해놓고 예시는 스토리지- 스토리지간임

스토리지에 저장된 x와 스토리지에 저장된 y 를같다고 assign 하면 포인터로 가리키게됨

- 예시로 y를 pop하든, x를 del하든 상호 값이 동기화됨을 보여줌

-스토리지-스토리지 간 assignment도 레퍼런스만 만드나봄..

Assignments from storage to a local storage variable also only assign a reference.

스토리지 - 로컬스토리지간 어사인먼트도 포인터만만듬

-functiong g 얘기인듯

-local storage variable is a variable defined inside a function. (The scope of the variable is limited to the function)

All other assignments to storage always copy.
Examples for this case are assignments to state variables or
to members of local variables of storage struct type, even if the local variable itself is just a reference.

다른 경우의 storage 어사인먼트는 무조건 카피를 발생시킨다.

이 경우 로컬 변수 자체가 참조에 불과하더라도 상태 변수 또는 스토리지 구조 유형의 로컬 변수 멤버에 대한 할당이 해당됩니다.

2019자료 확인필요

어렵넹

Events

_April — Tue, 15 Mar 2022 02:37:00 +0900

1. 이벤트 내뿜기(Emitting events)

- 실행하기, 부르기인가 싶었는데 그건 invoke임..

2단계가 필요하다.

- 우선 이벤트를 선언한다

event ExampleEvent(uint _exampleArgument);

- function 바디 안에서 선언한 이벤트를 emit한다.

function exampleFunction() external {
    emit ExampleEvent(5);
}

emit를 한 후에 이벤트를 invoke할수 있다.

이벤트는 주로 어퍼카멜케이스를 쓰고, 펑션은 주로 로워카멜케이스를 쓴다.

이걸 naming convention (작명관례)라한다.

이벤트를 emit한 컨트랙트를 eth_getLogs 를 통해 로그를 찍으면

이런 값을 리턴받는데, 데이터와 토픽에대해 논해보자.

DATA

만약 주소 하나를 넣어서 이벤트를 선언, emit해보자. 그러면

실제로 emit하는 부분은 이런 형태가되는데, 이 주소가 data안에 실제로 들어가있는 것을 볼수있다.

TOPIC

이벤트는 보통 최소 1개의 토픽을 가지는데, 보통 이벤트 시그네쳐 해쉬다.

Deployed(address)의 Keccak-256해시값은 f40f...인데 토픽안에 그 값이 들어가있는것을 볼수있다.

anonymous 키워드를 넣으면 익명이벤트를 만들수도있고, 가스도 세이브되지만

이벤트간 분간이 힘들어짐.

2 Multiple Arguments

펑션처럼 이벤트에도 여러개의 arguments 를 넣을수있다.

require(msg.sender == owner);

지정된조건이 없으면 종료됨

3. Indexed

이벤트 arguments에 indexed 키워드를 넣으면 필터링이 쉬워진다.

event HighScore(address indexed player);

인덱스 디테일 읽어도이해가안감

어드레스부터 다시 돌아야할것같음

다했지만 address부터 다시해야할듯

Contract to Contract

_April — Tue, 15 Mar 2022 00:08:25 +0900

체인샷 기본강의

이번에는 다른 스마트컨트랙을 부르는 법을 배운다

1. Enum

contract Player {
	enum Directions { Up, Down, Left, Right }
}

pure: function is isolated, does not read from anything outside itself and promises not to modify contract state.
view: function can read contract state but promises not to modify contract state.

뷰도 컨트랙트의 데이터를 바꾸지 않는다

2. Mint your own NFT collection and ship a Web3 app

_April — Sun, 20 Feb 2022 01:06:45 +0900

https://app.buildspace.so/projects/CO961ddb5f-f428-4608-9949-a9a2f461eb3f

buildspace

Start building cool web3 projects, earn NFTs, access secret work opportunities in crypto.

buildspace.so

메마 지갑 연결, 트젝, 펀딩등을 해보았으니 nft민팅 차례이다

이과제는 3단계로 이루어졌다.

1. NFT 로직관련 스마트 컨트랙트 짜기

2. 스마트컨트랙트 deploy

3. 프론트에 컨트랙트 연결하기

예제는 오픈제플린 erc721을 사용한다

근데 요새는 아주키가 만든 erc721a를 사용하는게 대세

Solidity 개념

상태변수 (State Variable)

상태 변수는 DB안에 있는 데이터처럼, 컨트랙트 저장소(이더리움 블록체인)에 영구적으로 저장되는 변수를 의미한다.

pragma solidity ^0.4.19;

contract ZombieFactory {

	uint a = 1;
}

tokenUri 는 links to a JSON file called the metadata

오픈씨 기준을 맞출것

컨트랙/오픈씨/레리블 테스트 조회

https://rinkeby.etherscan.io/

https://testnets.opensea.io/

Head to rinkeby.rarible.com.
Create this url: https://rinkeby.rarible.com/token/INSERT_DEPLOY_CONTRACT_ADDRESS_HERE:INSERT_TOKEN_ID_HERE.

json 바로 디코딩해서 nft 보여주는사이트

https://nftpreview.0xdev.codes/

NFT데이터 저장법

1. url - 쿨캣이 이렇게하지만 json/이미지 서버에 문제가 생기면 내려감

2. on chain - Loot가 이렇게함. 이더리움체인이 사는한 영원하나 저용량만 가능

온체인시 SVG를 사용한다

json 데이터는 링크 대신 base64 인코딩을한다

data:application/json;base64,베이스64인코딩내용

_setTokenURI(newItemId, "data:application/json;base64,ewogICAgIm5hbWUiOiAiRXBpY0xvcmRIYW1idXJnZXIiLAogICAgImRlc2NyaXB0aW9uIjogIkFuIE5GVCBmcm9tIHRoZSBoaWdobHkgYWNjbGFpbWVkIHNxdWFyZSBjb2xsZWN0aW9uIiwKICAgICJpbWFnZSI6ICJkYXRhOmltYWdlL3N2Zyt4bWw7YmFzZTY0LFBITjJaeUI0Yld4dWN6MGlhSFIwY0RvdkwzZDNkeTUzTXk1dmNtY3ZNakF3TUM5emRtY2lJSEJ5WlhObGNuWmxRWE53WldOMFVtRjBhVzg5SW5oTmFXNVpUV2x1SUcxbFpYUWlJSFpwWlhkQ2IzZzlJakFnTUNBek5UQWdNelV3SWo0TkNpQWdJQ0E4YzNSNWJHVStMbUpoYzJVZ2V5Qm1hV3hzT2lCM2FHbDBaVHNnWm05dWRDMW1ZVzFwYkhrNklITmxjbWxtT3lCbWIyNTBMWE5wZW1VNklERTBjSGc3SUgwOEwzTjBlV3hsUGcwS0lDQWdJRHh5WldOMElIZHBaSFJvUFNJeE1EQWxJaUJvWldsbmFIUTlJakV3TUNVaUlHWnBiR3c5SW1Kc1lXTnJJaUF2UGcwS0lDQWdJRHgwWlhoMElIZzlJalV3SlNJZ2VUMGlOVEFsSWlCamJHRnpjejBpWW1GelpTSWdaRzl0YVc1aGJuUXRZbUZ6Wld4cGJtVTlJbTFwWkdSc1pTSWdkR1Y0ZEMxaGJtTm9iM0k5SW0xcFpHUnNaU0krUlhCcFkweHZjbVJJWVcxaWRYSm5aWEk4TDNSbGVIUStEUW84TDNOMlp6ND0iCn0=")

이렇게 넣으면됨

여기서 랜덤화 하는법

random(string(abi.encodePacked("FIRST_WORD", Strings.toString(tokenId))));

The actual string FIRST_WORD and a stringified version of the tokenId. I combine these two strings using abi.encodePacked and then that combined string is what I use as the source of randomness.

근데 abi.encodePacked(a,b)라는 함수가 진짜 단순해서

 b = string(abi.encodePacked("hello", " world"));
    // b string: hello world

이정도라 이걸로안됨

ipfs

https://docs.ipfs.io/concepts/what-is-ipfs/#participation

What is IPFS? | IPFS Docs

What is IPFS? Let's just start with a one-line definition of IPFS: IPFS is a distributed system for storing and accessing files, websites, applications, and data. What does that mean, exactly? Let's say you're doing some research on aardvarks. (Just roll w

docs.ipfs.io

events (솔리디티)

https://docs.soliditylang.org/en/v0.4.21/contracts.html#events

Contracts — Solidity 0.4.21 documentation

Docs » Solidity in Depth » Contracts Edit on GitHub Contracts Contracts in Solidity are similar to classes in object-oriented languages. They contain persistent data in state variables and functions that can modify these variables. Calling a function on

docs.soliditylang.org

가스

https://ethereum.org/en/developers/docs/gas/

1. Buildspace : Intro to web3 -- build a web3 version of Twitter:

_April — Tue, 15 Feb 2022 00:39:30 +0900

https://app.buildspace.so/projects/CO02cf0f1c-f996-4f50-9669-cf945ca3fb0b

buildspace

Start building cool web3 projects, earn NFTs, access secret work opportunities in crypto.

buildspace.so

이 코스는 web3 페이지를 만든다. 그런데 그냥 만드는게 아니고

(1)이더리움 컨트랙트를 작성/ 테스트하고(run)

(2)컨트랙트를 온체인에 배포하고(deploy)

(3)프론트만들기- 아까 배포한 온체인을 적용해서 프론트만들기

이런 구조로 이루어져있다.

이렇게 웹3 앱과, 이더리움 스마트컨트랙트를 배포하는 절차를

Shipping이라고 한다.

(1)스마트컨트랙 작성: 서버코드 짜는것과 비슷하게 로직을 짠다

(2)컨트랙트 온체인에 배포: 원칙적으로는 모두가 배포된 스마트컨트랙에 접속하고, run할수 있게됨.

(3)클라 웹사이트만들기: 실제로 유저들이 활동하고 스마트컨트랙과 상호작용하는 단

강의를 따라 렛츠고

필요한 툴:

Hardhat, VSCode, replit (레플릿 진짜 편하다 진짜!! 코테 공부할때도 편했는데 js는 배포까지 해줌)

1. Hardhat

local Ethereum network를 쉽게 가동(spin up)하게 도와줌

-로컬 이더리움 네트워크 돌릴때(run) 씀

-테스트넷 이더리움도 줌

-테스트 어카운트도 줌-테스트넷 배포도 도와줌(deploy)

디테일한 장점 (로그도 쓰게 도와줌)

이제 npx hardhat run scripts/run.js 돌리면 자동으로 모르는 지갑이 뭔가 실행해줄건데 그게 다 하드햇 계정임

hre.ethers. 계열 코드도 다 하드햇에서지원함

컴파일시 hre

2.VSCode

컴파일/빌드/디플로이는 하드햇으로해도

결국 편집기가 필요하다

3.Replit

프론트 편집/배포 도와줌 그저 갓갓

4.Alchemy

gives us a simple way to deploy to the real Ethereum blockchain.

hardhat.config.js 에 알케미 API URL과 배포할 지갑 프라이빗키를 제공해야함

5. 이더스캔, 테스트넷

https://rinkeby.etherscan.io/

그냥 이더스캔에서 테스트넷으로 바꿔도 잘 검색이안되는데 아예여기서 하면 잘됨

주로 하는것

-프론트에 메마 연결확인 및 연결

-컨트랙트 Deploy시 프론트 연결단 변경

contractAddress in App.js바꾸기
ABI 변경 : artifacts 파일의 json 파일 복사해서 replit의 src/utils/WavePortal.json에 붙여넣기

-컨트랙트에 데이터 읽기

-컨트랙트에 데이터 쓰기

-컨트랙트에 funding

-돈보내기(트랜젝션)

-랜덤 만들기

-쿨타임 만들기

다 완성된 예제 코드

https://gist.github.com/adilanchian/93fbd2e06b3b5d3acb99b5723cebd925

솔리디티 개념

constructor

emit

require

js 개념

useEffect

전체코드

0. Buildspace 로 솔리디티 공부하기

_April — Wed, 9 Feb 2022 22:58:51 +0900

전엔 크립토 좀비를 했는데,

개념을 세세하고 꼼꼼하게 (정석이니까) 설명해서 좋은 교육자료였지만

실제로 빌드하지 않고 웹에서 예제를 돌려보는 정도여서 아쉬웠다.

또 클래식이어서 탄탄하긴 하지만 최신자료가 아니라서 또 아쉬웠다.

근데 (1)최신자료이고 (2)환경설정-빌드까지 하는 교육자료가 있다.

https://buildspace.so/

buildspace

Start building cool web3 projects, earn NFTs, access secret work opportunities in crypto.

buildspace.so

교육프로그램치곤 진짜 독특하게 디스코드로 바로 연결이되고

커리큘럼이 디코에 떠있음..

이거 5개를 제한기간내에 다 수료하면 nft도 줌

그래서 교육 사이트에 가입할때 메마주소랑 이메일주소 둘다 입력해야함

그럼 시작 렛츠고 렛츠고

LV.1 crypto zombies - 6 ERC721 & Crypto-Collectibles

_April — Tue, 30 Nov 2021 23:52:21 +0900

솔리디티에서는 프론트와 연결하는 라이브러리를제공한다

그걸 Web3 Provider.라고함(Web3.js안에 있음)

(1)Web3 Provider

Ethereum is made up of nodes that all share a copy of the same data.

Setting a Web3 Provider in Web3.js tells our code which node we should be talking to handle our reads and writes.

It's kind of like setting the URL of the remote web server for your API calls in a traditional web app.

오.. 어느 노드에 연결할지 직접 고를수 있다고합니다.

You could host your own Ethereum node as a provider.

However, there's a third party service that makes your life easier so you don't need to

maintain your own Ethereum node in order to provide a DApp for your users — Infura.

디앱을 만든다고 이더리움 노드를 채굴하진 않습니다. Infura가 노드 연결을 도와줍니다.

Infura
Infura is a service that maintains a set of Ethereum nodes with a caching layer for fast reads,

which you can access for free through their API.

Using Infura as a provider, you can reliably send and receive messages to/from the Ethereum blockchain

without needing to set up and maintain your own node.

infura는 노드에 접속하고 캐싱까지 제공합니다. 대박..

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

웹소켓으로 연결하는군요

근데 디앱은 동시에 여러사람이 사용하고, 읽기랑 쓰기가 동시에 일어나므로

유저가 프라이빗키로 트랜젝션에 사인을 해야한다.

Note: Ethereum (and blockchains in general) use a public / private key pair to digitally sign transactions.

If I change some data on the blockchain, I can prove via my public key that I was the one who signed it —

but since no one knows my private key, no one can forge a transaction for me.

그리고 이 프라이빗키를 관리하는게 메타마스크같은 지갑임.

Metamask
Metamask is a browser extension for Chrome and Firefox that lets users securely manage their

Ethereum accounts and private keys, and use these accounts to interact with websites that are using Web3.js.

Note: Metamask uses Infura's servers under the hood as a web3 provider, just like we did above —

but it also gives the user the option to choose their own web3 provider.

So by using Metamask's web3 provider, you're giving the user a choice,

and it's one less thing you have to worry about in your app.

웹3프로바이더 선택권을 준다는게 무슨소리지..? 잘이해안감

하여튼 지갑이 대부분 web3 js 를 쓰기때문에 넣기 쉽다.

LV.1 crypto zombies - 5 ERC721 & Crypto-Collectibles

_April — Sun, 28 Nov 2021 22:17:01 +0900

tokens, the ERC721 standard, and crypto-collectible assets에대해 다룬다

(1)Tokens

A token on Ethereum is basically just a smart contract that follows some common rules — namely it implements

a standard set of functions that all other token contracts share,

such as transferFrom(address _from, address _to, uint256 _tokenId) and balanceOf(address _owner).

그래서 erc20 토큰 찍어내는것은 쉬운편이다. 스마트 컨트랙을 따르면 되기때문

So basically a token is just a contract that keeps track of who owns how much of that token,

and some functions so those users can transfer their tokens to other addresses.

All ERC20 tokens share the same set of functions with the same names, they can all be interacted with in the same ways.

근데 기존 코인과 달리 코인을 쪼갤수없이 하나의 아이템을 올리고싶다면?

또 각각의 아이템을 다르게 만들고싶다면?=NFT

이게바로 ERC721토큰이다.

ERC721 tokens are not interchangeable since each one is assumed to be unique, and are not divisible.

You can only trade them in whole units, and each one has a unique ID.

그래서 nft도 트잭을 찍어보면 토큰갯수로 찍힌다.

1jdc토큰 = 1nft

(2)ERC721 Standard, Multiple Inheritance

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

  function balanceOf(address _owner) external view returns (uint256);
  function ownerOf(uint256 _tokenId) external view returns (address);
  function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
  function approve(address _approved, uint256 _tokenId) external payable;
}

이만큼 기능을 구현해주면 erc721이라 할수있음

내부는 개발자가 알아서 개발을 해줘야함

balanceOf :returns how many tokens that address owns. 주소주인이 가진 nft갯수

ownerOf : takes a token ID (in our case, a Zombie ID), and returns the address of the person who owns it

nft 주소로 주인 주소 찾기

transferFrom:

approve:

이두개는 세트인데

the token's owner first calls approve with the address he wants to transfer to, and the _tokenID .

The contract then stores who is approved to take a token, usually in a mapping (uint256 => address).

Then, when the owner or the approved address calls transferFrom,

the contract checks if that msg.sender is the owner or is approved by the owner to take the token,

and if so it transfers the token to him.

실제 transfer은 ERC721.sol의 emit Transfer(_from, _to, _tokenId); 통해 이루어짐

approve의 경우 2단계임

You, the owner, call approve and give it the _approved address of the new owner, and the _tokenId you want him to take.
The new owner calls transferFrom with the _tokenId. Next, the contract checks to make sure the new owner has been already approved, and then transfers him the token.

이것도 다 체크하고 실제 어프루브는 ERC721.sol의 emit Approval(msg.sender, _approved, _tokenId);

(3) Preventing Overflows and Underflows

안한거

such as some extra checks to make sure users don't accidentally transfer their zombies to address 0 (which is called "burning" a token — basically it's sent to an address that no one has the private key of, essentially making it unrecoverable).

토큰소각은 찐소각이아니라 없는주소/못쓰는주소로 보내는거였군..

컨트랙 보안강화

uint8 는 십진수 0~255까지저장할수 있다.

uint8 number = 255;
number++;

근데 이래버리면 다시 0으로 돌아간다. 이게 overflow

underflow는 음수 지정하면 나는 에러.

이런걸 검증하는 라이브러리가 SafeMath

import "./safemath.sol";

contract ZombieOwnership is ZombieAttack, ERC721 {

  using SafeMath for uint256;

이런식으로 넣으면 커버됨

이제 ++ -- 대신 .add .sub이런식으로 쓰면 라이브러리 사용가능

(4)주석

The standard in the Solidity community is to use a format called natspec, which looks like this:

/// @title A contract for basic math operations
/// @author H4XF13LD MORRIS  
/// @notice For now, this contract just adds a multiply function
contract Math {
  /// @notice Multiplies 2 numbers together
  /// @param x the first uint.
  /// @param y the second uint.
  /// @return z the product of (x * y)
  /// @dev This function does not currently check for overflows
  function multiply(uint x, uint y) returns (uint z) {
    // This is just a normal comment, and won't get picked up by natspec
    z = x * y;
  }
}

@notice explains to a user what the contract / function does. @dev is for explaining extra details to developers.

all tags are optional. But at the very least, leave a @dev note explaining what each function does.

LV.1 crypto zombies - 4 Zombie Battle System

_April — Sun, 28 Nov 2021 17:46:52 +0900

(1)Payable

visibility modifiers

when and where the function can be called from

private: it's only callable from other functions inside the contract;
internal: like private but can also be called by contracts that inherit from this one
external: can only be called outside the contract
public: can be called anywhere, both internally and externally.

state modifiers

how the function interacts with the BlockChain

view: running the function, no data will be saved/changed.
pure: the function not save any data to the blockchain, it also doesn't read any data from the blockchain.

Both of these don't cost any gas to call if they're called externally from outside the contract (but they do cost gas

if called internally by another function)

payable

a special type of function that can receive Ether.

contract OnlineStore {
  function buySomething() external payable {
    // Check to make sure 0.001 ether was sent to the function call:
    require(msg.value == 0.001 ether);
    // If so, some logic to transfer the digital item to the caller of the function:
    transferThing(msg.sender);
  }
}

msg.value is a way to see how much Ether was sent to the contract

돈전송할땐 무조건 payable 모디파이어를 사용해야함

안그럼reject됨

(2)Withdraws

contract GetPaid is Ownable {
  function withdraw() external onlyOwner {
    address payable _owner = address(uint160(owner()));
    _owner.transfer(address(this).balance);
  }
}

Or in a contract with a buyer and a seller, you could save the seller's address in storage, then when someone

purchases his item, transfer him the fee paid by the buyer: seller.transfer(msg.value).

These are some examples of what makes Ethereum programming really cool — you can have decentralized

marketplaces like this that aren't controlled by anyone.

1,2번 잘 이해잘안가서 다시해봐야할듯..

아님 다른예제를 좀더보거나..

코딩은 따라칠수있는데 뭘하는건지 잘모르겠음

(3)난수생성하기

Random number generation via keccak256 ->보안문제가있음.

이유: 컨트랙트상에서 펑션을 부르면 네트워크의 노드들에게 트렌젝션을 broadcast한다. POW에 따라 노드들은 이 브로드캐스트된 트젝들을 모아서 빨리 문제를 풀려고한다.

그래서 한노드가 문제를 풀면, 다풀었다고 네트워크의 다른 노드들에게 퍼블리시함. 그러면 다른 노드들은 문제풀기를 중단하고 다른 노드가 제출한 트랜젝션이 유효한지만 인증한다. 유효하다고 확인되면 인증하고 다같이 다음 블락의 문제풀기로 넘어감. 근데 이과정이 랜덤번호 만들기를 악용할수 있게되는데,

예를들면 동전뒤집기가 있음.
Let's say we had a coin flip contract — heads you double your money, tails you lose everything.

Let's say it used the above random function to determine heads or tails.

(random >= 50 is heads, random < 50 is tails).

노드를 돌리는 입장에선, 문제를 푼다음 다른노드에 결과를 공유할지 말지 정할수가 있다. 그래서 실패하면 공유하지않고 다시 계산할수있다. 그래서 성공하는값이나오면 다른 노드에 공유하는것이다. 그런다음 다음블록 문제풀기로 넘어갈수가 있다.

=>근데 이럴려면 해당노드가 다른 노드보다 빠르게 일을해야 가능한거아닌가?

내 노드가 재수가없어서 6번씩 false가 나오면 7번 연산해야하는데 그동안 딴노드는 1번만 계산해서 먼저 끝냈다고 퍼블리시할수도있잖아.

라고생각했더니 뒤에 이얘기가나옴ㅋㅋㅋㅋ

Of course, since tens of thousands of Ethereum nodes on the network are competing to solve the next block,

my odds of solving the next block are extremely low.

It would take me a lot of time or computing resources to exploit this profitably —

but if the reward were high enough (like if I could bet $100,000,000 on the coin flip function),

it would be worth it for me to attack.

역시 그럴 확률은 적지만, 보상이 클경우 분명 악용을 시도하는 사람이 있을거라는것.

어쨌거나! 해결법:

we may cover using oracles (a secure way to pull data in from outside of Ethereum) to generate secure random numbers from outside the blockchain.

하여튼 이더리움체인상에서 난수를 생성하지 말라고..

(4)refactory

require을 modifier로 바꾸기

이번챕터는 무난했음

LV.1 crypto zombies - 3 Advanced Solidity Concepts

_April — Fri, 26 Nov 2021 21:54:34 +0900

contract ownership, gas costs, code optimization, and security 등 중요한걸 배운다고한다

궁금했다. 가보자고

(1)Immutability of Contracts

그렇지 이더리움에 한번 올리면 못고치지

after you deploy a contract to Ethereum, it’s immutable, which means that it can never be modified or updated again.

his is one reason security is such a huge concern in Solidity. If there's a flaw in your contract code, there's no way for you to patch it later. You would have to tell your users to start using a different smart contract address that has the fix.

스마트컨트랙을 ㅠ 나중에 ㅠ 바꾸는서비스가 ㅠ 어딨어요

한번에 잘해야한다..가 얼마나 불가능한일인지 개발자들은 알것이다.

For this reason, it often makes sense to have functions that will allow you to update key portions of the DApp.

가능한한 유연하게, 고칠수있게 만들어야한다.

For example, instead of hard coding the CryptoKitties contract address into our DApp, we should probably have a setKittyContractAddress function that lets us change this address in the future in case something happens to the CryptoKitties contract.

그렇다..

(2)Ownable Contracts

Ownable — meaning they have an owner (you) who has special privileges.

external이어도 내가만든 컨트랙이 아니면 그 함수 가져다 쓸수없게함

OpenZeppelin is a library of secure and community-vetted smart contracts that you can use in your own DApps

상속할때처럼 is Ownable하면 됨

(3)Modifier

함수에 붙어서 함수에 어떤 제약을 걸어주기도 하고 부가적인 기능을 만들어준다.(함수를 꾸며준다.)

modifier는 함수를 꾸며주는데 꾸며준 다음에 본래 함수를 어디서 실행할지 결정해야 한다. 이 때 이 ‘어디서 실행할 지' 결정해주는 것이 _ 이다. (placeholder라고도 함)

  modifier onlyOwner() {
    require(isOwner());
    _;
  }

예제를 보면

require(isOwner()); 를 통해

현재 컨트랙트의 함수를 실행한 어드레스의 주소(msg.sender)가 이 컨트랙트에 owner라고 정의된 주소와 같느냐를 물어본다. 그 후에 언더스코어 _; 가 등장한다. 이 때 바로 이 언더스코어 부분에서 onlyOwner가 꾸며준 함수가 실행되는 구조로 동작한다.

언제쓰냐:

100개의 함수가 있는데, 그 100개의 함수들은 나이가 성인인지 아닌지 체크를 해야하는 require가 필요 하다고 가정해보자.
각 함수마다 당연히 require(_age>17, "You are under 18 years old")를 하나하나 일일히 써야한다.
즉 reqire문을 100 번 써야한다. (100번의반복)

19세 미만이 아니라 15세 미만으로 나이제한이 바뀌면?
각 함수의 require 마다 require(_age>14, "You are under 15 years old") 라고 고쳐야하는데
100 번이나 고쳐야한다.

이러한 불편함을 극복하기 위해서 Modifier을 쓴다.

(4)Gas

그치 뭐할때마다 이더를 가스로 내야하져

In Solidity, your users have to pay every time they execute a function on your DApp using a currency called gas. Users buy gas with Ether (the currency on Ethereum), so your users have to spend ETH in order to execute functions on your DApp.

How much gas is required to execute a function depends on how complex that function's logic is. Each individual operation has a gas cost based roughly on how much computing resources will be required to perform that operation (e.g. writing to storage is much more expensive than adding two integers). The total gas cost of your function is the sum of the gas costs of all its individual operations.

Because running functions costs real money for your users, code optimization is much more important in Ethereum than in other programming languages. If your code is sloppy, your users are going to have to pay a premium to execute your functions — and this could add up to millions of dollars in unnecessary fees across thousands of users.

최적화가 곧 돈이다.. 무써운 세계군요

Why is gas necessary?

Ethereum is like a big, slow, but extremely secure computer. 이 비유 좋은듯. When you execute a function, every single node on the network needs to run that same function to verify its output — thousands of nodes verifying every function execution is what makes Ethereum decentralized, and its data immutable and censorship-resistant.

The creators of Ethereum wanted to make sure someone couldn't clog up the network with an infinite loop, or hog all the network resources with really intensive computations. So they made it so transactions aren't free, and users have to pay for computation time as well as storage.

이래서 가스비 폭발할때마다 비탈릭이 욕을 바가지로 먹는거군요..

그래서 기본 uint대신(256)

uint8, uint16, uint32 쓸수있음 써서최소화 시키라는것임. 완전 몇메가바이트밖에 없던 씨-씨쁠쁠 시절과 똑같은.. 접근이네요..

근데 헬인게 씨쁠쁠은 나중에 숫자가생각보다 커지면 타입바꾸면되는데

솔리디티는 바꾸지도못함.. wow

더 황당한거

You'll also want to cluster identical data types together (i.e. put them next to each other in the struct) so that Solidity can minimize the required storage space. For example, a struct with fields uint c; uint32 a; uint32 b; will cost less gas than a struct with fields uint32 a; uint c; uint32 b; because the uint32 fields are clustered together.

???

이건왠지모르겠는데 데이터유형 맞춰야 가스비가 덜든다고함. 솔리디티 최적화 난이도 무엇

(5)Time Units

시간 native unit이 있음

The variable now will return the current unix timestamp of the latest block (the number of seconds that have passed since January 1st 1970).

Note: Unix time is traditionally stored in a 32-bit number. This will lead to the "Year 2038" problem, when 32-bit unix timestamps will overflow and break a lot of legacy systems. So if we wanted our DApp to keep running 20 years from now, we could use a 64-bit number instead — but our users would have to spend more gas to use our DApp in the meantime. Design decisions! ㅋㅋ장난하나용

나머지 시간유닛은 seconds, minutes, hours, days, weeks and years

(6)Function modifiers with arguments

// A mapping to store a user's age:
mapping (uint => uint) public age;

// Modifier that requires this user to be older than a certain age:
modifier olderThan(uint _age, uint _userId) {
  require(age[_userId] >= _age);
  _;
}

// Must be older than 16 to drive a car (in the US, at least).
// We can call the `olderThan` modifier with arguments like so:
function driveCar(uint _userId) public olderThan(16, _userId) {
  // Some function logic
}

이거 좋아보인다.

Note: calldata is somehow similar to memory, but it's only available to external functions.

calldata must be used when declaring an external function's dynamic parameters.

(7) View functions don't cost gas

This is because view functions don't actually change anything on the blockchain – they only read the data.

(8)Storage is Expensive

One of the more expensive operations in Solidity is using storage — particularly writes.
This is because every time you write or change a piece of data, it’s written permanently to the blockchain.

Avoid writing data to storage except when absolutely necessary. Sometimes this involves seemingly inefficient programming logic — like rebuilding an array in memory every time a function is called instead of simply saving that array in a variable for quick lookups.

In most programming languages, looping over large data sets is expensive. But in Solidity, this is way cheaper than using storage if it's in an external view function, since view functions don't cost your users any gas. (And gas costs your users real money!).

어쩐지 블록체인 느리더라..... big O를 이기는 "가스비원칙"

그래서 memory를쓰는게 훨싸고, 만약 view안에서 불렀다면 완전 공짜

단,

memory arrays must be created with a length argument. They currently cannot be resized like storage arrays can with array.push(),

(9)Loops

이건그냥 루프문

LV.1 crypto zombies - 2 Zombies Attack Their Victims

_April — Fri, 26 Nov 2021 01:36:00 +0900

생각보다 강의가 길다?

(1)Mappings and Addresses

new data types: mapping and address.

이더주소 자체가 데이터타입이라니..!

Address

an address is owned by a specific user (or a smart contract).

The Ethereum blockchain is made up of accounts, which you can think of like bank accounts. An account has a balance of Ether (the currency used on the Ethereum blockchain), and you can send and receive Ether payments to other accounts, just like your bank account can wire transfer money to other bank accounts.

Mapping

A mapping is essentially a key-value store for storing and looking up data.

// For a financial app, storing a uint that holds the user's account balance:
mapping (address => uint) public accountBalance;
// Or could be used to store / lookup usernames based on userId
mapping (uint => string) userIdToName;

In the first example, the key is an address and the value is a uint, and in the second example the key is a uint and the value a string.

(2)Msg.sender

there are certain global variables that are available to all functions. One of these is msg.sender, which refers to the address of the person (or smart contract) who called the current function.

Note: In Solidity, function execution always needs to start with an external caller. A contract will just sit on the blockchain doing nothing until someone calls one of its functions. So there will always be a msg.sender.

(3)Require

if else대신 require을 쓴다..

the function will throw an error and stop executing if some condition is not true:

function sayHiToVitalik(string memory _name) public returns (string memory) {
  // Compares if _name equals "Vitalik". Throws an error and exits if not true.
  // (Side note: Solidity doesn't have native string comparison, so we
  // compare their keccak256 hashes to see if the strings are equal)
  require(keccak256(abi.encodePacked(_name)) == keccak256(abi.encodePacked("Vitalik")));
  // If it's true, proceed with the function:
  return "Hi!";
}

솔리디티 스트링 비교없는거 몹시 신박하다

비교를위한 암호화..

근데 참이아니면 뭘리턴한다는거임? 리턴할거없어서 에러날거같은뎅

(4)Inheritance

솔리디티는 예제도 "도지"다

투더문~~

(5)Import

이거야뭐.. 설마 파이썬처럼 제가 직접 넣어야할까요?

에디터가 넣어줄거라 굳게믿습니다

(6)Storage vs Memory (Data location)

In Solidity, there are two locations you can store variables — in storage and in memory.

Storage refers to variables stored permanently on the blockchain. Memory variables are temporary, and are erased between external function calls to your contract. Think of it like your computer's hard disk vs RAM.

기본적으로 건드릴필요는없다

Most of the time you don't need to use these keywords because Solidity handles them by default. State variables (variables declared outside of functions) are by default storage and written permanently to the blockchain, while variables declared inside functions are memory and will disappear when the function call ends.

언제 건드리냐면 : structs and arrays

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

  Sandwich[] sandwiches;

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

    // ^ Seems pretty straightforward, but solidity will give you a warning
    // telling you that you should explicitly declare `storage` or `memory` here.

    // So instead, you should declare with the `storage` keyword, like:
    Sandwich storage mySandwich = sandwiches[_index];
    // ...in which case `mySandwich` is a pointer to `sandwiches[_index]`
    // in storage, and...
    mySandwich.status = "Eaten!";
    // ...this will permanently change `sandwiches[_index]` on the blockchain.

    // If you just want a copy, you can use `memory`:
    Sandwich memory anotherSandwich = sandwiches[_index + 1];
    // ...in which case `anotherSandwich` will simply be a copy of the 
    // data in memory, and...
    anotherSandwich.status = "Eaten!";
    // ...will just modify the temporary variable and have no effect 
    // on `sandwiches[_index + 1]`. But you can do this:
    sandwiches[_index + 1] = anotherSandwich;
    // ...if you want to copy the changes back into blockchain storage.
  }
}

(7)More on Function Visibility

In addition to public and private, Solidity has two more types of visibility for functions: internal and external.

internal is the same as private, except that it's also accessible to contracts that inherit from this contract.

external is similar to public, except that these functions can ONLY be called outside the contract — they can't be called by other functions inside that contract. We'll talk about why you might want to use external vs public later.

(8)Interacting with other contracts

오 이런게된다고..

first we need to define an interface.

공개된 다른플젝 인터페이스 긁어와서 init할때 이더 주소 넣으면 된다.

근데 fav address라고 되어있어서 그 플젝주소넣어야하는지 홀더주소 넣어야하는지 잘모르겠음

(9)Handling Multiple Return Values

난 멀티플리턴되는게 좋더라.. 클래스로 커버안되는 그런게있음

LV.1 crypto zombies - 1 Making the Zombie Factory

_April — Thu, 25 Nov 2021 01:54:48 +0900

(1) Lesson Overview

DNA따라 캐릭터 조형이 바뀜을보여줌

nft는 실제로 이렇게 조형되서 예제를 이렇게 보여준듯

(2) Contracts

Solidity's code is encapsulated in contracts. A contract is the fundamental building block of Ethereum applications

맞다

그래서 컨트랙만봐도 러그 50퍼는 피할수있다

이걸위해 나는 이 강의를 시작한것이다

-Version Pragma

All solidity source code should start with a "version pragma" — a declaration of the version of the Solidity compiler this code should use.

이걸이렇게 명시하다니 독특하다

보통은 메타데이터에 쓰면 컴파일러가 관리해주는데..

pragma solidity >=0.5.0 <0.6.0;

contract HelloWorld {

}

이런식으로 명시해야 헬로월드 컨트랙이 작동한다.

(3)State Variables & Integers

이제 데이터에 대해 배운다.

State variables are permanently stored in contract storage. This means they're written to the Ethereum blockchain. Think of them like writing to a DB.

데이터가 체인에영원히 남는다이거야.. 정말작은 nft파일은

이렇게 아예 이더리움체인 자체에 올릴수있다. 진정한 탈중앙화

이런 state variable의 데이터타입 중에는

uint가있다.

The uint data type is an unsigned integer, meaning its value must be non negative.

기본형: uint256 짧은거 uint8, uint16, uint32

There's also an int data type for signed integers.

데이터타입 다 알려줘 감질나..

이렇게 데이터타입 세분화된이유는 코드 양에따라 이더리움 가스비가 다르기때문임 (이거 주워들은거라 확실치않음) =>코드양 최소화 마치 c++같군요

(4)Math

Addition: x + y
Subtraction: x - y,
Multiplication: x * y
Division: x / y
Modulus / remainder: x % y (for example, 13 % 5 is 3, because if you divide 5 into 13, 3 is the remainder)

그냥 수식

exponential operator
uint x = 5 ** 2; // equal to 5^2 = 25

(5)Structs

클래스대신 스트럭이라고 하는군요

struct Person {
  uint age;
  string name;
}

Structs allow you to create more complicated data types that have multiple properties.

객체랑은 다른듯함 객체는 속성과 동작인데 이건 속성(데이터)만 있는듯

(6) Arrays

fixed arrays and dynamic arrays

다이나믹만있으면 나는 행복합니다

// Array with a fixed length of 2 elements:
uint[2] fixedArray;
// another fixed Array, can contain 5 strings:
string[5] stringArray;
// a dynamic Array - has no fixed size, can keep growing:
uint[] dynamicArray;

Person[] public people;

퍼블릭으로 만들면 Solidity will automatically create a getter method for it.

Other contracts would then be able to read from,(퍼블릭이니까) but not write to, this array. So this is a useful pattern for storing public data in your contract.

(7)Function Declarations

function eatHamburgers(string memory _name, uint _amount) public {

}

퍼블릭붙이는 위치가 독특하네.. variables뒤다.

플러터도 그러더니 솔리디티도 private는 변수명을 _로시작함

Note that we're specifying the function visibility as public. We're also providing instructions about where the _name variable should be stored- in memory.

그럼 memory 안붙이면 메모리에 안둔다는건지..?

By value, which means that the Solidity compiler creates a new copy of the parameter's value and passes it to your function. This allows your function to modify the value without worrying that the value of the initial parameter gets changed.
By reference, which means that your function is called with a... reference to the original variable. Thus, if your function changes the value of the variable it receives, the value of the original variable gets changed.

(8) Working With Structs and Arrays

그냥뻔함 새 struct만들어서 dynamic array에넣음

(9)Private / Public Functions

It's good practice to mark your functions as private by default, and then only make public the functions you want to expose to the world.

(10)More on Functions

return value,

Function modifiers

view function, meaning it's only viewing the data but not modifying it.

pure functions, which means you're not even accessing any data in the app.

(11)Keccak256 and Typecasting

Ethereum has the hash function keccak256 built in, which is a version of SHA3. A hash function basically maps an input into a random 256-bit hexadecimal number. A slight change in the input will cause a large change in the hash.

이걸 다양하게 쓸수있는데 랜덤만들때도 씀..

//6e91ec6b618bb462a4a6ee5aa2cb0e9cf30f7a052bb467b0ba58b8748c00d2e5
keccak256(abi.encodePacked("aaaab"));
//b1f078126895a1424524de5321b339ab00408010b7cf0e6ed451514981e58aa9
keccak256(abi.encodePacked("aaaac"));

주의: Secure random-number generation in blockchain is a very difficult problem. 보안문제 있을수있음

Typecasting

uint8 a = 5;
uint b = 6;
// throws an error because a * b returns a uint, not uint8:
uint8 c = a * b;
// we have to typecast b as a uint8 to make it work:
uint8 c = a * uint8(b);

살짝 c++의 악몽이..

12는 복습이라 생략

(13)Events

Events are a way for your contract to communicate that something happened on the blockchain to your app front-end, which can be 'listening' for certain events and take action when they happen.

리스너대신 events와 emit사용

// declare the event
event IntegersAdded(uint x, uint y, uint result);

function add(uint _x, uint _y) public returns (uint) {
  uint result = _x + _y;
  // fire an event to let the app know the function was called:
  emit IntegersAdded(_x, _y, result);
  return result;
}

(14)Web3.js

Now we need to write a javascript frontend that interacts with the contract.
Ethereum has a Javascript library called Web3.js.
In a later lesson, we'll go over in depth how to deploy a contract and set up Web3.js.

아예 자바스크립트를 세트로가르치는군...

Solidity 입문 | crypto zombies 크립토 좀비

_April — Thu, 25 Nov 2021 00:07:00 +0900

요새 민팅을 많이하는데

러그도 몇번 당하고

민팅도 선착순에서 밀리고 개발자로서 부끄러운일이 한두개가아니다..

그냥 그때그때 배우지말고 간단하게라도 공부해서 제대로 격파하기로 결정

모든 nft의 근본은 이더리움=솔리디티라 솔리디티로 결정

다행히 솔리디티 초급강의를 제공하는곳이 있다.

https://cryptozombies.io/

#1 Solidity Tutorial & Ethereum Blockchain Programming Course | CryptoZombies

CryptoZombies is The Most Popular, Interactive Solidity Tutorial That Will Help You Learn Blockchain Programming on Ethereum by Building Your Own Fun Game with Zombies — Master Blockchain Development with Web3, Infura, Metamask & Ethereum Smart Contracts

cryptozombies.io

카테고리따라 빠르게 격파할예정

LV.1 Beginner to Intermediate Smart Contracts

This course will teach you how to build a game on Ethereum.

1 Making the Zombie Factory
2 Zombies Attack Their Victims
3 Advanced Solidity Concepts
4 Zombie Battle System
5 ERC721 & Crypto-Collectibles
6 App Front-ends & Web3.js

LV.2 Advanced Solidity Path: Get In-depth Knowledge

1 Deploying DApps with Truffle
2 Testing Smart Contracts with Truffle
3 How to Build an Oracle
4 How to Build an Oracle - Part 2
5 How to Build an Oracle - Part 3

LV.3 Beyond Ethereum: Explore the Blockchain Ecosystem

Libra Basics
All About Binance Chain
Intro to zkSync
Advanced zkSync Concepts

레벨3 코스는 좀 올드함. 바낸체인은 nft에선 천대받는곳인데...

최근코스는 SOL, polygon, luna 하다못해 klay가나음

컴파일러 언어와 인터프리터언어

_April — Wed, 20 Nov 2019 00:38:04 +0900

컴퓨터는 1과 0으로 말하고(기계어, low level language), 인간은 컴퓨터와 대화하기 위해 코드(high level language)를 사용한다.

그래서 컴퓨터가 인간의 언어를 알아듣게 변환하는 과정이 필요한데,

그 방식은 컴파일과 인터프리터이다.

컴파일러언어의 예: C

인터프리터 언어의 예: javascript, python

이 방식에 따라 언어간 실행 속도의 차가 존재한다. 한번 컴파일되면 컴파일러 언어가 실행속도가 더 빠르다.

우리가 외국어 영상을 보는 상황이라고 하자.

컴파일언어는 자막을 달아+인코딩 되어 업로딩 된 영상을 보는것이다. 한번 업로드되면 멈추지않고 빠르게 영상을 볼수있다.

이 자막+인코딩+영상 세트를 목적파일이라고 한다(object file, .o파일형태이다)

반면 인터프리터는 옆에서 그때 그때 통역가가 번역을 해주는것이다.

따라서 소리가 겹치지 않게 하기 위해 가끔 영상을 일시 정지해야할때도 있다.

어쩌면 번역할 시간을 벌기위해 영상을 0.5배속으로 봐야할수도 있다.

이 비유는 다른 항목에도 적용된다.

1.에러의경우

컴파일러는 자막을 만들때 뜻이 통하지않는/ 모르는 문장이 있는지 확인하고 영상 업로드전에 작업을 중지한다.

따라서 컴파일언어는 에러가 있으면 빌드가 되지 않아 실행할 수 없다. 반면 컴파일이 끝났다면 오류가 없다는것이다.

바면 인터프리터는 한참 통역을 하다가 갑자기 어? 나 이뜻모르겠어 미안! 하고 통역을 멈춰버릴것이다. 사전을 준비하거나 다른 인터프리터를 구하거나 이건 차후의 문제가 되어버린다.

즉 에러가 있건 없건 프로그램은 실행되나, 실행 중 오류가 있는 곳에서 프로그램이 멈춘다..

2.준비 시간

실행시 컴파일이 시간이 좀더 걸리는것도 마찬가지다. 프로그램 실행시 컴파일언어는 빌드 시간이 걸린다.

빌드시간은 즉 자막을 달아 인코딩하는 시간이다. 따라서 소스코드의 크기가 클수록 컴파일시간이 오래걸린다.

반면 인터프리터언어는 바로 실행된다. 준비된 통역가가 바로 나오기만 하면 되기 때문이다.

인터프리터 언어가 코드실행에 걸리는 시간은 조금더 느리지만, 많이쓰이는 이유는 다음과 같다.

1. high-level language여서 기계의 언어보다는 인간의 언어에 가깝다. 즉 습득하기 더 쉽다.

2. 유지보수 생산성이 높다. 빌드시간이 짧아서 바로바로 코딩하며 확인하기도 쉽고, 대부분의 인터프리터 언어(c이상의 고급언어)를 사용할때는 메모리관리를 할필요가 없어지기 때문이다.

npm설치한 프로그램이 뭘해도 command not found가 뜰때

_April — Tue, 10 Sep 2019 11:11:15 +0900

mac, 리눅스 공통

npm global 설치한후 실행시 계속 command not found 가 뜰때

보통 경로문제다. 하지만 .bash 파일을 수정하다 잘돌아가던것까지 박살나기 쉽다. 우회하자.

터미널에서 경로 세팅을 다시해주자

npm config set prefix /usr/local

npm 통해 설치되는 파일 경로가 로컬파일이된다. 숨김파일이다.

기존에 npm 글로벌로 깔았더라도 새로 받는다. 기존 npm 파일받은건 잊자.(저는 서버리스 받고있었음)

npm i -g serverless

그다음 프로그램명을 치면 잘된다

기본 패스 설정이 이상했던것!

출처

https://stackoverflow.com/a/45132080