shit4

EIPs/README.md

@@ -0,0 +1,54 @@
+# EIP Contribution Plan 
+
+## VISION
+
+### Why Open-Source?
+- Recognition from the global blockchain community
+- Small but practical, core contributions
+- Learn 24 standards and perform open-source contributions
+- Top-notch experience and career in the industry
+
+## Schedule
+
+### Learning Period
+
+#### April 1 - April 14 (2 weeks)
+- Each person to research 1 EIP
+
+#### April 15 - May 8 (2 weeks)
+- Each person to research 2 EIPs
+
+*One week break for personal schedules, etc.*
+*You have to notify a week in advance of your personal schedule break*
+
+#### Tasks
+- Study EIP theory and code, write on Medium (in Korean/English) / Total of 6 EIP researches per person
+- In addition to studying your own research, also familiarize yourself with the research done by other team members / Learn a total of 24 EIPs
+- Update status on Telegram every Saturday by 12 pm
+- Review status and receive feedback in Orakle online sessions
+- If an EIP is too simple, it may be counted as 0.5 (personal judgement)
+
+### Topic Selection
+
+#### May 9 - May 16 (1 week)
+
+#### Task
+- Select EIP contribution topic
+
+### Contribution Period
+
+#### May 16 - July 16 (7 weeks)
+
+#### Tasks
+- Perform EIP contribution
+- Write documentation (github/medium)
+
+*One week break for personal schedules, etc.* 
+*You have to notify a week in advance of your personal schedule break*
+
+#### July 16 - July 23 (1 week)
+
+#### Task
+- Prepare for final presentation
+
+#### July 27 - Final Presentation

EIPs/eip-2.md

@@ -0,0 +1,257 @@
+## <center>EIP-2: Homestead Hard-fork 분석</center>
+
+<div style="text-align: right"> Seungmin Kim </div>
+<div style="text-align: right"> 2024-04-04 </div>
+
+
+
+### 개요
+이 문서는 오라클 일반세션 오픈소스 팀 EIP 분석 프로젝트의 일환으로 EIP-2 에서 제안하는 내용과 그 분석에 대해서 서술합니다.
+
+
+### 변경사항. 
+
+#### 1. 트랜잭션을 통해 스마트계약을 생성하는 경우의 가스 비용을 21,000 에서 53,000으로 증가시킵니다. 
+
+트랜잭션을 보내고 받는 사람 주소가 빈 문자열인 경우 차감되는 초기 가스는 현재의 경우인 21,000이 아니라 53,000에 tx 데이터의 가스 비용을 더한 금액입니다. CREATE opcode를 사용한 계약 생성은 영향을 받지 않습니다.
+
+스마트 계약을 생성하는 방식은 두개가 존재합니다. 
+
+1. 트랜잭션 To 를 빈 주소(0x0)로 전송하는 방법: 21,000 gas
+
+2. CREATE opcode를 사용하는 방법: 32,000 gas
+
+홈스테드 이전의 이더리움 버전의 경우 비용이 32,000인 CREATE opcode 보다 비용이 21,000인 거래를 통해 계약을 생성하는 데 초과 인센티브가 있습니다. 
+
+또한 가스비용이 저렴하기 때문에, 자살 환불(suicide refunds)방법을 통해 11,664개의 가스만 사용하여 이더리움을 전송할 수 있었습니다.
+
+자살 환불(suicide refunds)방법은 환불되는 가스의 주소를 전송할 주소로 지정하여 계약을 배포하는 방법입니다. 
+
+<b>자살환불을 시도하는 python code</b>
+```python
+from ethereum import tester as t
+> from ethereum import utils
+> s = t.state()
+> c = s.abi_contract('def init():\n suicide(0x47e25df8822538a8596b28c637896b4d143c351e)', endowment=10**15)
+> s.block.get_receipts()[-1].gas_used
+11664
+>s.block.get_balance(utils.normalize_address(0x47e25df8822538a8596b28c637896b4d143c351e))
+1000000000000000
+```
+
+<b>code</b>
+```go
+TxGas uint64 = 21000 // Per transaction not creating a contract. NOTE: Not payable on data of calls between transactions.
+TxGasContractCreation uint64 = 53000 // Per transaction that creates a contract. NOTE: Not payable on data of calls between transactions.
+
+...
+
+CreateGas uint64 = 32000 // Once per CREATE operation & contract-creation transaction.
+
+...
+
+SelfdestructRefundGas uint64 = 24000 // suicide 는 현재 selfdestruct 로 변경되었음.
+```
+
+```go
+// IntrinsicGas computes the 'intrinsic gas' for a message with the given data.
+func IntrinsicGas(data []byte, accessList types.AccessList, isContractCreation bool, isHomestead, isEIP2028, isEIP3860 bool) (uint64, error) {
+ // Set the starting gas for the raw transaction
+ var gas uint64
+ //eip2: 계약 생성 트랜잭션의 경우 가스비를 추가함.
+ if isContractCreation && isHomestead {
+ gas = params.TxGasContractCreation
+ } else {
+ gas = params.TxGas
+ }
+...
+```
+
+#### 2. S 값이 (secp256k1 ∙ n)/2 보다 큰 모든 거래 서명은 이제 유효하지 않은 것으로 간주됩니다. 
+
+홈스테드 이전 버전에서는 공격자가 원래의 서명을 통해 새로운 유효한 서명을 생성할 수 있습니다. 이더리움의 ECDSA 서명은 (r,s) 의 쌍 값과 복구 식별자 'v' 를 가집니다. 그러나 이 서명 값을 알고 있다면,유효한 서명을 s를 사용하여 하나 더 생성할 수 있습니다.
+
+(r, n - s) 와 v를 뒤집으면(27-> 28, 28->27), 새로운 유효한 서명이 생성됩니다.
+
+이더리움은 이더 가치 전송이나 다른 거래에 대한 입력으로 주소를 사용하기 때문에 이는 심각한 보안 결함은 아니지만 공격자가 거래를 방해할 수 있으므로 불편함을 초래할 수 있습니다. 
+
+```go
+func VerifySignature(pubkey, hash, signature []byte) bool {
+ if len(signature) != 64 {
+ return false
+ }
+ var r, s btcec.ModNScalar
+ if r.SetByteSlice(signature[:32]) {
+ return false // overflow
+ }
+ if s.SetByteSlice(signature[32:]) {
+ return false
+ }
+ sig := btc_ecdsa.NewSignature(&r, &s)
+ key, err := btcec.ParsePubKey(pubkey)
+ if err != nil {
+ return false
+ }
+ // Reject malleable signatures. libsecp256k1 does this check but btcec doesn't.
+ if s.IsOverHalfOrder() {
+ return false
+ }
+ return sig.Verify(hash, key)
+}
+```
+
+
+
+#### 3. 계약 생성 프로세스에서 계약 코드를 상태에 추가하기 위한 최종 가스 요금을 지불할 만큼 가스가 충분하지 않은 경우 빈 계약을 유지하는 대신 계약 생성이 실패되도록 합니다. 
+
+최종 가스 수수료를 지불할 가스가 충분하지 않은 경우 계약 생성에 실패하면, 다음과 같은 이점이 있습니다.
+
+(i) 현재의 "성공, 실패 또는 빈 계약"의 결과 계약 생성 프로세스의 결과에 보다 직관적인 "성공 또는 실패" 결과만을 생성합니다.
+
+(ii) 계약 생성이 완전히 성공하지 않으면 계약 계정이 전혀 생성되지 않으므로 생성 실패를 더 쉽게 감지할 수 있습니다. 그리고
+
+(iii) 거래가 실패하더라도, 가스가 환불된다는 보장이 있으므로 계약 생성을 더 안전하게 만듭니다.
+
+<b>code</b>
+```go
+ // We first execute the transaction at the highest allowable gas limit, since if this fails we
+ // can return error immediately.
+ failed, result, err := execute(ctx, call, opts, hi)
+ if err != nil {
+ return 0, nil, err
+ }
+ if failed {
+ if result != nil && !errors.Is(result.Err, vm.ErrOutOfGas) {
+ return 0, result.Revert(), result.Err
+ }
+ return 0, nil, fmt.Errorf("gas required exceeds allowance (%d)", hi)
+ }
+```
+
+
+
+#### 4. 현재 공식에서 난이도 조정 알고리즘을 변경합니다: 
+
+$$
+\text{block\\_diff} = \text{parent\\_diff} + \frac{\text{parent\\_diff}}{2048} \times \begin{cases} 
+1, & \text{if block\\_timestamp} - \text{parent\\_timestamp} < 13 \\
+-1, & \text{otherwise}
+\end{cases} + \text{int}\left(2^{\left(\frac{\text{block.number}}{100000} - 2\right)}\right)
+$$
+
+를 
+
+$$
+\text{block\\_diff} = \text{parent\\_diff} + \frac{\text{parent\\_diff}}{2048} \times \max\left(1 - \frac{\text{block\\_timestamp} - \text{parent\\_timestamp}}{10}, -99\right) + \text{int}\left(2^{\left(\frac{\text{block.number}}{100000} - 2\right)}\right)
+$$
+
+로 변경합니다. 최소 난이도는 그대로 유지되며 최소 난이도 아래로는 변경되지 않습니다. 
+
+기존의 난이도 알고리즘은 네트워크의 해시레이크가 급격하게 변하는 경우, 빠르게 이에 적응하는 것이 어렵습니다. 때문에 2015년 9월 이더리움 프로토콜에서 과도한 수의 채굴자가 $\text{parent\\_timestamp} + 1$ 의 타임스탬프 값(1초의 블록 생성 시간을)을 가지는 블록들을 채굴하던 문제가 있었고, 이는 블록 시간 분포를 왜곡 시켰습니다.
+
+
+
+따라서 새로운 난이도 알고리즘은 이러한 문제를 해결하도록 제안되었습니다. 제안된 새로운 공식은 대략적으로 평균값을 목표로 하고 있으며, 이 공식은 24초보다 긴 평균 블록 시간이 수학적으로 불가능하다는 것을 증명할 수 있습니다.
+
+시간 차이가 아닌 $\frac{\text{block\\_timestamp} - \text{parent\\_timestamp}}{10}$을 주요 입력 변수로 사용하는 것은 알고리즘의 대략적인 특성을 직접적으로 유지하는 역할을 합니다. 
+
+이는 채굴자들이 약간 높은 난이도를 가진 블록을 생성하여 가능한 모든 포크를 확실히 이길 수 있도록 타임스탬프 차이를 정확히 $1$로 설정하는 과도한 유인을 방지합니다.
+
+$-99$의 상한은 두 블록이 시간상 매우 멀리 떨어져 있는 경우 난이도가 크게 떨어지지 않도록 하는 역할을 합니다.
+
+#### Code 
+<b>Homestead</b>
+
+```go
+func calcDifficultyHomestead(time, parentTime uint64, parentNumber, parentDiff *big.Int) *big.Int {
+ // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2.mediawiki
+ // algorithm:
+ // diff = (parent_diff +
+ // (parent_diff / 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
+ // ) + 2^(periodCount - 2)
+
+ bigTime := new(big.Int).SetUint64(time)
+ bigParentTime := new(big.Int).SetUint64(parentTime)
+
+ // holds intermediate values to make the algo easier to read & audit
+ x := new(big.Int)
+ y := new(big.Int)
+
+ // 1 - (block_timestamp -parent_timestamp) // 10
+ x.Sub(bigTime, bigParentTime)
+ x.Div(x, big10)
+ x.Sub(common.Big1, x)
+
+ // max(1 - (block_timestamp - parent_timestamp) // 10, -99)))
+ if x.Cmp(bigMinus99) < 0 {
+ x.Set(bigMinus99)
+ }
+
+ // (parent_diff + parent_diff // 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
+ y.Div(parentDiff, params.DifficultyBoundDivisor)
+ x.Mul(y, x)
+ x.Add(parentDiff, x)
+
+ // minimum difficulty can ever be (before exponential factor)
+ if x.Cmp(params.MinimumDifficulty) < 0 {
+ x = params.MinimumDifficulty
+ }
+
+ // for the exponential factor
+ periodCount := new(big.Int).Add(parentNumber, common.Big1)
+ periodCount.Div(periodCount, ExpDiffPeriod)
+
+ // the exponential factor, commonly refered to as "the bomb"
+ // diff = diff + 2^(periodCount - 2)
+ if periodCount.Cmp(common.Big1) > 0 {
+ y.Sub(periodCount, common.Big2)
+ y.Exp(common.Big2, y, nil)
+ x.Add(x, y)
+ }
+
+ return x
+}
+```
+
+<b>Frontier</b>
+
+```go
+func calcDifficultyFrontier(time, parentTime uint64, parentNumber, parentDiff *big.Int) *big.Int {
+ diff := new(big.Int)
+ adjust := new(big.Int).Div(parentDiff, params.DifficultyBoundDivisor)
+ bigTime := new(big.Int)
+ bigParentTime := new(big.Int)
+
+ bigTime.SetUint64(time)
+ bigParentTime.SetUint64(parentTime)
+
+ if bigTime.Sub(bigTime, bigParentTime).Cmp(params.DurationLimit) < 0 {
+ diff.Add(parentDiff, adjust)
+ } else {
+ diff.Sub(parentDiff, adjust)
+ }
+ if diff.Cmp(params.MinimumDifficulty) < 0 {
+ diff = params.MinimumDifficulty
+ }
+
+ periodCount := new(big.Int).Add(parentNumber, common.Big1)
+ periodCount.Div(periodCount, ExpDiffPeriod)
+ if periodCount.Cmp(common.Big1) > 0 {
+ // diff = diff + 2^(periodCount - 2)
+ expDiff := periodCount.Sub(periodCount, common.Big2)
+ expDiff.Exp(common.Big2, expDiff, nil)
+ diff.Add(diff, expDiff)
+ diff = common.BigMax(diff, params.MinimumDifficulty)
+ }
+
+ return diff
+}
+```
+
+<b>Reference</b>
+
+https://eips.ethereum.org/EIPS/eip-2
+
+https://medium.com/coinmonks/learn-solidity-lesson-37-creating-and-destroying-contracts-6921ae32413a
+
+https://github.com/ethereum/go-ethereum/compare/v1.3.3...v1.3.