diff --git a/public/content/translations/ja/developers/tutorials/smart-contract-security-guidelines/index.md b/public/content/translations/ja/developers/tutorials/smart-contract-security-guidelines/index.md index 81636f3cf98..f1bc86565ec 100644 --- a/public/content/translations/ja/developers/tutorials/smart-contract-security-guidelines/index.md +++ b/public/content/translations/ja/developers/tutorials/smart-contract-security-guidelines/index.md @@ -1,15 +1,12 @@ --- -title: スマートコントラクトに対するセキュリティ・ガイドライン -description: Dapp開発時に参照すべきセキュリティ・ガイドラインのチェックリスト +title: "スマートコントラクトに対するセキュリティ・ガイドライン" +description: "Dapp開発時に参照すべきセキュリティ・ガイドラインのチェックリスト" author: "Trailofbits" -tags: - - "Solidity" - - "スマートコントラクト" - - "セキュリティ" +tags: ["solidity", "smart contracts", "security"] skill: intermediate lang: ja published: 2020-09-06 -source: セキュアなコントラクトの構築 +source: Building secure contracts sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/guidelines.md --- @@ -19,76 +16,76 @@ sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/devel まず、コードを書く前に、コントラクトの設計について十分に議論を深める必要があります。 -### ドキュメンテーションおよび使用 {#documentation-and-specifications} +### ドキュメントと仕様 {#documentation-and-specifications} ドキュメンテーションは様々な水準で作成でき、コントラクトの実装時に内容を修正する必要があります。 -- **平易な英語で書かれたシステムの説明**では、コントラクトが実行する内容を説明し、コードベースの前提条件を記述します。 -- **スキーマとアーキテクチャのダイアグラム**では、コントラクトで実行されるやりとりや、システムの状態マシンについて記述します。 [Slitherのプリンター機能](https://github.com/crytic/slither/wiki/Printer-documentation)は、スキーマを生成する上で有益です。 -- **コード内容を徹底的に文書化する。** Solidityの場合、[Natspecフォーマット](https://solidity.readthedocs.io/en/develop/natspec-format.html)を使用できます。 +- **システムの平易な英語による説明**。コントラクトが何を行い、コードベースにどのような前提条件があるかを記述します。 +- **スキーマとアーキテクチャ図**。コントラクト間の相互作用やシステムの状態マシンを含みます。 [Slitherプリンター](https://github.com/crytic/slither/wiki/Printer-documentation)は、これらのスキーマの生成に役立ちます。 +- **徹底的なコードドキュメント**。Solidityでは[Natspec形式](https://docs.soliditylang.org/en/develop/natspec-format.html)が使用できます。 -### オンチェーン処理とオフチェーン処理の比較 {#on-chain-vs-off-chain-computation} +### オンチェーン計算とオフチェーン計算 {#onchain-vs-offchain-computation} -- **できるだけ多くのコードを、オフチェーンで処理するようにします。**オンチェーンのレイヤーに含まれるコードは、小規模になるようにしてください。 オンチェーンでの検証がシンプルに実行できるように、オフチェーンのコードでデータを前処理します。 順序付きリストが必要か確認します。 必要な場合は、オフチェーンでリストをソートしてから、オンチェーンでは順序のみをチェックするようにします。 +- \*\*できるだけ多くのコードをオフチェーンに置いてください。\*\*オンチェーンレイヤーは小さく保ちます。 オンチェーンでの検証がシンプルになるように、オフチェーンのコードでデータを前処理します。 順序付きリストが必要か確認します。 必要な場合は、オフチェーンでリストをソートしてから、オンチェーンでは順序のみをチェックするようにします。 ### アップグレード可能性 {#upgradeability} -アップグレードに関する様々なソリューションについては、[こちらのブログ投稿](https://blog.trailofbits.com/2018/09/05/contract-upgrade-anti-patterns/)で検討しています。 コード開発を開始する事前に、アップグレードに対応するか否かをはっきり決定してください。 この決定により、どのような構造のコードを開発するべきかが変わってきます。 一般論として、以下を推奨します: +[私たちのブログ投稿](https://blog.trailofbits.com/2018/09/05/contract-upgrade-anti-patterns/)で、さまざまなアップグレード可能性のソリューションについて説明しました。 コード開発を開始する事前に、アップグレードに対応するか否かをはっきり決定してください。 この決定により、どのような構造のコードを開発するべきかが変わってきます。 一般論として、以下を推奨します: -- **アップグレード可能性よりも、[コントラクトのマイグレーション](https://blog.trailofbits.com/2018/10/29/how-contract-migration-works/)を優先すること**。システムのマイグレーションは、アップグレード可能性が提供する利点の多くを有し、アップグレード可能性の欠点がありません。 -- **委任呼び出しプロキシのパターンよりも、データ分離のパターンを使用すること**。あなたのプロジェクトに明確な抽象化による分離が含まれる場合、データ分離をわずかに修正するだけでアップグレードが可能になります。 委任呼び出しのプロキシ は、EVMの知識が必要であり、エラー発生の頻度が高まります。 -- **デプロイする前に、マイグレーション/アップグレードの手順を文書化すること**。ガイドラインが設定されていない場合、ストレスを受けながら作業する必要があるため、ミスを犯しやすくなります。 遵守すべき手順を前もって策定しておきましょう。 具体的には、以下を定めます: +- \*\*アップグレード可能性よりも[コントラクトのマイグレーション](https://blog.trailofbits.com/2018/10/29/how-contract-migration-works/)を優先すること。\*\*マイグレーションシステムはアップグレード可能なシステムと同じ利点の多くを持ちながら、その欠点はありません。 +- **delegatecallproxyパターンよりもデータ分離パターンを使用すること。** プロジェクトに明確な抽象化分離がある場合、データ分離を使用したアップグレードは、わずかな調整しか必要ありません。 委任呼び出しのプロキシ は、EVMの知識が必要であり、エラー発生の頻度が高まります。 +- **デプロイ前に、移行/アップグレードの手順を文書化すること。** ガイドラインがない状態でストレス下で対応しなければならない場合、ミスを犯すでしょう。 遵守すべき手順を前もって策定しておきましょう。 具体的には、以下を定めます: - 新たなコントラクトを開始する呼び出し。 - キーの保存場所と、アクセス方法。 - デプロイの確認方法。 デプロイ後のスクリプトを開発、テストしておきます。 -## 実装に関するガイドライン {#implementation-guidelines} +## 実装ガイドライン {#implementation-guidelines} -**シンプルさを追求する**。常に、目的を達成する上で最もシンプルなソリューションを使用してください。 あなたのソリューションは、チーム全員が理解できるものでなければなりません。 +\*\*シンプルさを追求すること。\*\*常に目的に合った最もシンプルなソリューションを使用してください。 あなたのソリューションは、チーム全員が理解できるものでなければなりません。 ### 関数の構成 {#function-composition} コードベースのアーキテクチャは、レビューしやすいものでなければなりません。 コードの正確性を判定しにくくするようなアーキテクチャ関連の決定は避けてください。 -- **システムのロジックを分割する**。複数のコントラクトに分割するか、類似の関数(認証、算術塩酸など)をグループ化しましょう。 -- **明確な目的を持つ小規模の関数を書く**。レビュー作業が容易になり、コンポーネントごとのテストが可能になります。 +- \*\*システムのロジックを分割すること。\*\*複数のコントラクトに分けるか、類似した関数(例: 認証、算術演算など)をグループ化します。 +- **明確な目的を持つ小さな関数を書くこと。** これにより、レビューが容易になり、個々のコンポーネントのテストが可能になります。 ### 継承 {#inheritance} -- **継承を管理可能な水準に抑える**。ロジックを分割するために継承を活用すべきですが、プロジェクト全体における継承ツリーの深さと広さをなるべく小さくするように努めてください。 -- **Slitherの[継承プリンター](https://github.com/crytic/slither/wiki/Printer-documentation#inheritance-graph)でコントラクトの階層を確認する**。継承プリンターは、階層の規模を確認する上で役立ちます。 +- \*\*継承を管理可能なものに保つこと。\*\*継承はロジックを分割するために使用すべきですが、プロジェクトでは継承ツリーの深さと幅を最小限に抑えることを目指すべきです。 +- **Slitherの[継承プリンター](https://github.com/crytic/slither/wiki/Printer-documentation#inheritance-graph)を使用してコントラクトの階層を確認してください。** 継承プリンターは、階層のサイズを確認するのに役立ちます。 ### イベント {#events} -- **すべての重要操作をロギングする**。イベントログは、開発時におけるコントラクトのデバッグやデプロイ後の監視に役立ちます。 +- **すべての重要な操作をログに記録してください。** イベントは、開発中のコントラクトのデバッグやデプロイ後の監視に役立ちます。 -### 既知の落とし穴を回避する {#avoid-known-pitfalls} +### 既知の落とし穴を避ける {#avoid-known-pitfalls} -- **最も一般的なセキュリティの問題に注意します**。よくある問題点については、[Ethernaut CTF](https://ethernaut.openzeppelin.com/)、[Capture the Ether](https://capturetheether.com/)、[Not so smart contracts](https://github.com/crytic/not-so-smart-contracts/)などの様々なオンラインリソースを活用してください。 -- **[Solidityドキュメント](https://solidity.readthedocs.io/en/latest/)の警告セクションに注意する**。警告セクションを通じて、言語における把握しにくい振る舞いを把握することができます。 +- **最も一般的なセキュリティ問題に注意してください。** [Ethernaut CTF](https://ethernaut.openzeppelin.com/)、[Capture the Ether](https://capturetheether.com/)、[Not so smart contracts](https://github.com/crytic/not-so-smart-contracts/)など、一般的な問題について学ぶためのオンラインリソースはたくさんあります。 +- **[Solidityドキュメント](https://docs.soliditylang.org/en/latest/)の警告セクションに注意してください。** 警告セクションは、言語の自明でない挙動について知らせてくれます。 ### 依存関係 {#dependencies} -- **実証済みのライブラリを使用する**。実証済みのライブラリからコードをインポートすることで、バグが多いコードを書く可能性が低くなります。 ERC-20コントラクトを作成する場合は、 [OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20)を使用してください。 -- **依存性マネージャーを使用し、コードのコピーアンドペーストを避ける**。外部ソースに依存する場合は、元ソースに基づき最新状態を保つ必要があります。 +- **十分にテストされたライブラリを使用すること。** 十分にテストされたライブラリからコードをインポートすることで、バグの多いコードを書く可能性が低くなります。 ERC20コントラクトを書きたい場合は、[OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20)を使用してください。 +- **依存関係マネージャーを使用し、コードのコピー&ペーストは避けてください。** 外部ソースに依存する場合は、元のソースに合わせて最新の状態に保つ必要があります。 ### テストと検証 {#testing-and-verification} -- **完全な単体テストを作成する**。質の高いソフトウェアを開発するには、包括的なテスト一式が不可欠です。 -- **[Slither](https://github.com/crytic/slither)、[Echidna](https://github.com/crytic/echidna)、および[Manticore](https://github.com/trailofbits/manticore)用のカスタムチェックとプロパティを作成する**。自動化ツールを通じて、コントラクトのセキュリティを高めることができます。 効率的なチェックおよびプロパティを作成するには、本ガイドの該当記事を参照してください。 -- **[crytic.io](https://crytic.io/)を使用する**。Cryticは、GitHubと統合されており、Slitherのプライベート検出器にアクセスできる他、Echidnaからカスタムのプロパティチェックを実行することができます。 +- **徹底的な単体テストを書くこと。** 広範なテストスイートは、高品質なソフトウェアを構築するために不可欠です。 +- **[Slither](https://github.com/crytic/slither)、[Echidna](https://github.com/crytic/echidna)、[Manticore](https://github.com/trailofbits/manticore)のカスタムチェックとプロパティを記述すること。** 自動化ツールは、コントラクトの安全性を確保するのに役立ちます。 効率的なチェックおよびプロパティを作成するには、本ガイドの該当記事を参照してください。 +- \*\*[crytic.io](https://crytic.io/)を使用してください。\*\*CryticはGitHubと統合されており、プライベートなSlither検出器へのアクセスを提供し、Echidnaからカスタムプロパティチェックを実行します。 ### Solidity {#solidity} -- **Solidityのバージョンは、0.4や0.6ではなく0.5を使用する**。現在のところ、Solidity 0.5が最もセキュアなバージョンであり、0.4よりもビルトインプラクティスが優れています。 一方、0.6は現時点において本番環境の使用に耐えうる安定性を持たず、さらなるアップデートが必要な状態です。 -- **安定したバージョンでコンパイルし、最新リリースで警告をチェックする。**最新バージョンのコンパイラを使って、コードの問題が報告されないことを確認してください。 ただし、Solidityはリリース間隔が短く、過去においてもコンパイラにバグが含まれていた場合が多いため、デプロイに最新バージョンを用いることは推奨しません(Slitherの[推奨solcバージョン](https://github.com/crytic/slither/wiki/Detector-Documentation#recommendation-33)を参照)。 -- **インラインアセンブラを使用しない**。アセンブラを使用するには、EVMの専門知識が必要です。 イエローペーパーを_マスターしていない場合_、EVMコードを書かないでください。 +- **Solidityは0.4や0.6よりも0.5を優先すること。** 私たちの意見では、Solidity 0.5は0.4よりも安全で、より優れた組み込みプラクティスを備えています。 一方、0.6は現時点において本番環境の使用に耐えうる安定性を持たず、さらなるアップデートが必要な状態です。 +- **コンパイルには安定版リリースを使用し、警告のチェックには最新リリースを使用すること。** 最新のコンパイラバージョンでコードに問題が報告されないことを確認してください。 しかし、Solidityはリリースサイクルが速く、コンパイラのバグの履歴があるため、デプロイに最新バージョンを使用することはお勧めしません(Slitherの[solcバージョン推奨](https://github.com/crytic/slither/wiki/Detector-Documentation#recommendation-33)を参照)。 +- **インラインアセンブリは使用しないこと。** アセンブリにはEVMの専門知識が必要です。 イエローペーパーを_マスター_していない場合は、EVMコードを書かないでください。 -## デプロイに関するガイドライン {#deployment-guidelines} +## デプロイガイドライン {#deployment-guidelines} コントラクトの開発が完了し、デプロイしたら、以下を確認します: -- **コントラクトの動作を監視する**。ログを監視し、コントラクトやウォレットが不正利用された場合はただちに対応できる状態を保ってください。 -- **あなたの連絡先情報を[blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts)に追加する**。このリストに登録することで、プロジェクトにおけるセキュリティ上の欠陥が発見された場合に、サードパーティから連絡を受けやすくなります。 -- **特権ユーザーのウォレットを保護する**。キーをハードウェアウォレットに保管する場合は、この[ベストプラクティス](https://blog.trailofbits.com/2018/11/27/10-rules-for-the-secure-use-of-cryptocurrency-hardware-wallets/)に従ってください。 -- **事故対応計画を策定する**。スマートコントラクトは、不正利用される可能性があります。 開発したコントラクトにバグが含まれていない場合でも、攻撃者はコントラクト所有者の鍵を悪用しようとする可能性があります。 +- **コントラクトを監視してください。** ログを監視し、コントラクトやウォレットが不正利用された場合に備えて、対応できるようにしておきましょう。 +- **連絡先情報を[blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts)に追加してください。** このリストは、セキュリティ上の欠陥が発見された場合に第三者があなたに連絡するのに役立ちます。 +- **権限のあるユーザーのウォレットを保護すること。** ハードウェアウォレットにキーを保管する場合は、[私たちのベストプラクティス](https://blog.trailofbits.com/2018/11/27/10-rules-for-the-secure-use-of-cryptocurrency-hardware-wallets/)に従ってください。 +- **インシデント対応計画を準備しておくこと。** スマートコントラクトが侵害される可能性があることを考慮してください。 開発したコントラクトにバグが含まれていない場合でも、攻撃者はコントラクト所有者の鍵を悪用しようとする可能性があります。 diff --git a/public/content/translations/ja/developers/tutorials/stealth-addr/index.md b/public/content/translations/ja/developers/tutorials/stealth-addr/index.md new file mode 100644 index 00000000000..43e1c71f77d --- /dev/null +++ b/public/content/translations/ja/developers/tutorials/stealth-addr/index.md @@ -0,0 +1,436 @@ +--- +title: "ステルスアドレスの使用" +description: "ステルスアドレスを使用すると、ユーザーは匿名で資産を送金できます。 この記事を読むと、ステルスアドレスとは何か、またその仕組みを説明し、匿名性を保つ方法でステルスアドレスを使用する方法を理解し、ステルスアドレスを使用するウェブベースのアプリケーションを作成できるようになります。" +author: Ori Pomerantz +tags: ["Stealth address", "privacy", "cryptography", "rust", "wasm"] +skill: intermediate +published: 2025-11-30 +lang: ja +sidebarDepth: 3 +--- + +あなたはBillです。 理由は省きますが、あなたは「世界女王アリス」キャンペーンに寄付をして、アリスに寄付したことを知らせ、彼女が勝った場合に報酬を得たいと考えています。 残念ながら、彼女の勝利は保証されていません。 「太陽系女帝キャロル」という競合キャンペーンがあります。 もしキャロルが勝ち、あなたがアリスに寄付したことを彼女が知ったら、あなたは面倒なことになります。 そのため、自分のアカウントからアリスのアカウントに200 ETHを単純に送金することはできません。 + +[ERC-5564](https://eips.ethereum.org/EIPS/eip-5564)がその解決策です。 このERCは、匿名での送金に[ステルスアドレス](https://nerolation.github.io/stealth-utils)を使用する方法を説明しています。 + +**警告**: ステルスアドレスの背後にある暗号技術は、私たちが知る限り、健全です。 しかし、潜在的なサイドチャネル攻撃が存在します。 [以下](#go-wrong)では、このリスクを軽減するために何ができるかを見ていきます。 + +## ステルスアドレスの仕組み {#how} + +この記事では、ステルスアドレスを2つの方法で説明します。 1つ目は[その使用方法](#how-use)です。 この記事の残りの部分を理解するには、このパートで十分です。 次に、[その背後にある数学的な説明](#how-math)があります。 暗号技術に興味がある場合は、この部分もお読みください。 + +### 簡易版 (ステルスアドレスの使い方) {#how-use} + +アリスは2つの秘密鍵を作成し、対応する公開鍵を公開します (これらを組み合わせて単一の倍長のメタアドレスにすることができます)。 ビルも秘密鍵を作成し、対応する公開鍵を公開します。 + +一方の当事者の公開鍵と他方の秘密鍵を使用することで、アリスとビルだけが知っている共有シークレットを導き出すことができます (公開鍵だけからは導き出すことはできません)。 この共有シークレットを使用して、ビルはステルスアドレスを取得し、そこに資産を送ることができます。 + +アリスも共有シークレットからアドレスを取得しますが、公開した公開鍵の秘密鍵を知っているため、そのアドレスから引き出すことができる秘密鍵も取得できます。 + +### 数学的な仕組み (なぜステルスアドレスがこのように機能するのか) {#how-math} + +標準的なステルスアドレスでは、[楕円曲線暗号 (ECC)](https://blog.cloudflare.com/a-relatively-easy-to-understand-primer-on-elliptic-curve-cryptography/#elliptic-curves-building-blocks-of-a-better-trapdoor) を使用して、より少ない鍵ビットでより優れたパフォーマンスを得ながら、同じレベルのセキュリティを維持します。 しかし、ほとんどの場合、それを無視して通常の算術を使用していると見なすことができます。 + +誰もが知っている数字、_G_ があります。 _G_ を掛けることができます。 しかし、ECCの性質上、_G_ で割ることは事実上不可能です。 イーサリアムにおける公開鍵暗号技術の一般的な仕組みは、秘密鍵 _Ppriv_ を使用してトランザクションに署名し、それが公開鍵 _Ppub = GPpriv_ によって検証されるというものです。 + +アリスは2つの秘密鍵、_Kpriv_ と _Vpriv_ を作成します。 _Kpriv_ はステルスアドレスから資金を使用するために、_Vpriv_ はアリスに属するアドレスを表示するために使用されます。 アリスは次に公開鍵 _Kpub = GKpriv_ と _Vpub = GVpriv_ を公開します。 + +ビルは3番目の秘密鍵 _Rpriv_ を作成し、_Rpub = GRpriv_ を中央レジストリに公開します (ビルはアリスに送ることもできましたが、ここではキャロルが聞き耳を立てていると仮定します)。 + +ビルは _RprivVpub = GRprivVpriv_ を計算し、アリスもこれを知っていると期待します (下記で説明)。 この値は _S_ (共有シークレット) と呼ばれます。 これにより、ビルは公開鍵 _Ppub = Kpub+G\*hash(S)_ を得ます。 この公開鍵から、彼はアドレスを計算し、好きなリソースをそこに送ることができます。 将来、アリスが勝った場合、ビルは彼女に _Rpriv_ を伝えて、リソースが自分からのものであることを証明できます。 + +アリスは _RpubVpriv = GRprivVpriv_ を計算します。 これにより、彼女も同じ共有シークレット _S_ を得ます。 彼女は秘密鍵 _Kpriv_ を知っているので、_Ppriv = Kpriv+hash(S)_ を計算できます。 この鍵により、彼女は _Ppub = GPpriv = GKpriv+G\*hash(S) = Kpub+G\*hash(S)_ から得られるアドレスの資産にアクセスできます。 + +アリスがDaveの「世界征服キャンペーンサービス」に業務を委託できるように、別の閲覧用鍵があります。 アリスは、デイブに公開アドレスを知らせて、より多くの資金が利用可能になったときに通知してもらうことには前向きですが、デイブにキャンペーン資金を使われることは望んでいません。 + +閲覧と使用は別の鍵を使うため、アリスはデイブに _Vpriv_ を渡すことができます。 するとデイブは _S = RpubVpriv = GRprivVpriv_ を計算でき、それによって公開鍵 (_Ppub = Kpub+G\*hash(S)_) を得ることができます。 しかし、_Kpriv_ がなければ、デイブは秘密鍵を取得できません。 + +まとめると、これらが異なる参加者によって知られている値です。 + +| アリス | 公開済み | ビル | デイブ | | +| ------------------------------------------------------------------------- | ----------------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ----------------------------------------------- | +| G | G | G | G | | +| _Kpriv_ | - | - | - | | +| _Vpriv_ | - | - | _Vpriv_ | | +| _Kpub = GKpriv_ | _Kpub_ | _Kpub_ | _Kpub_ | | +| _Vpub = GVpriv_ | _Vpub_ | _Vpub_ | _Vpub_ | | +| - | - | _Rpriv_ | - | | +| _Rpub_ | _Rpub_ | _Rpub = GRpriv_ | _Rpub_ | | +| _S = RpubVpriv = GRprivVpriv_ | - | _S = RprivVpub = GRprivVpriv_ | _S = _RpubVpriv_ = GRprivVpriv_ | | +| _Ppub = Kpub+G\*hash(S)_ | - | _Ppub = Kpub+G\*hash(S)_ | _Ppub = Kpub+G\*hash(S)_ | | +| _Address=f(Ppub)_ | - | _Address=f(Ppub)_ | _Address=f(Ppub)_ | _Address=f(Ppub)_ | +| _Ppriv = Kpriv+hash(S)_ | - | - | - | | + +## ステルスアドレスがうまくいかない場合 {#go-wrong} + +_ブロックチェーン上に秘密はありません_。 ステルスアドレスはプライバシーを提供できますが、そのプライバシーはトラフィック分析に対して脆弱です。 簡単な例を挙げると、ビルがあるアドレスに資金を供給し、すぐにトランザクションを送信して _Rpub_ 値を公開するとします。 アリスの _Vpriv_ がなければ、これがステルスアドレスであると確信することはできませんが、そうである可能性が高いです。 次に、そのアドレスからアリスのキャンペーン資金アドレスにすべてのETHを送金する別のトランザクションが見られます。 証明はできないかもしれませんが、ビルがアリスのキャンペーンに寄付した可能性が高いです。 キャロルは間違いなくそう思うでしょう。 + +ビルにとって、_Rpub_ の公開とステルスアドレスへの資金供給を分離することは簡単です (異なる時間に、異なるアドレスから行います)。 しかし、それだけでは不十分です。 キャロルが探すパターンは、ビルがあるアドレスに資金を提供し、その後アリスのキャンペーン資金がそこから引き出すというものです。 + +1つの解決策は、アリスのキャンペーンが直接資金を引き出すのではなく、第三者への支払いに使用することです。 アリスのキャンペーンがデイブの世界征服キャンペーンサービスに10 ETHを送金した場合、キャロルはビルがデイブの顧客の1人に寄付したことしか知りません。 デイブに十分な顧客がいれば、キャロルはビルが彼女と競合するアリスに寄付したのか、それともキャロルが気にしていないアダム、アルバート、アビゲイルに寄付したのかを知ることはできません。 アリスは支払いにハッシュ化された値を含め、その後デイブにプリイメージを提供することで、それが自分の寄付であることを証明できます。 あるいは、前述のように、アリスがデイブに彼女の _Vpriv_ を渡せば、彼はすでに支払いが誰からのものかを知っています。 + +この解決策の主な問題は、その秘密がビルに利益をもたらす場合に、アリスが秘密を守ることを気にしなければならないという点です。 アリスは、ビルの友人であるボブも彼女に寄付するように、自分の評判を維持したいかもしれません。 しかし、彼女がビルを暴露することを気にしない可能性もあります。なぜなら、そうすれば彼はキャロルが勝った場合に何が起こるかを恐れるからです。 ビルは結果的にアリスをさらに支援することになるかもしれません。 + +### 複数のステルスレイヤーの使用 {#multi-layer} + +ビルのプライバシーを保護するためにアリスに頼る代わりに、ビル自身がそれを行うことができます。 彼は架空の人物、ボブとベラのために複数のメタアドレスを生成できます。 ビルは次にETHをボブに送り、「ボブ」(実際にはビル) がそれをベラに送ります。 「ベラ」(これもビル) がそれをアリスに送ります。 + +キャロルは依然としてトラフィック分析を行い、ビルからボブ、ベラ、アリスへのパイプラインを見ることができます。 しかし、「ボブ」と「ベラ」が他の目的でETHを使用している場合、アリスがステルスアドレスから既知のキャンペーンアドレスにすぐに引き出したとしても、ビルがアリスに何かを転送したようには見えません。 + +## ステルスアドレスアプリケーションの作成 {#write-app} + +この記事では、[GitHub](https://github.com/qbzzt/251022-stealth-addresses.git) で入手可能なステルスアドレスアプリケーションについて説明します。 + +### ツール {#tools} + +使用できる[TypeScriptのステルスアドレスライブラリ](https://github.com/ScopeLift/stealth-address-sdk)があります。 しかし、暗号操作はCPUを集中的に使用することがあります。 私はそれらを[Rust](https://rust-lang.org/)のようなコンパイル言語で実装し、[WASM](https://webassembly.org/)を使用してブラウザでコードを実行することを好みます。 + +[Vite](https://vite.dev/)と[React](https://react.dev/)を使用します。 これらは業界標準のツールです。もし馴染みがない場合は、[このチュートリアル](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/)を使用できます。 Viteを使用するには、Nodeが必要です。 + +### ステルスアドレスの動作を見る {#in-action} + +1. 必要なツールをインストールします: [Rust](https://rust-lang.org/tools/install/) と [Node](https://nodejs.org/en/download)。 + +2. GitHubリポジトリをクローンします。 + + ```sh + git clone https://github.com/qbzzt/251022-stealth-addresses.git + cd 251022-stealth-addresses + ``` + +3. 前提条件をインストールし、Rustコードをコンパイルします。 + + ```sh + cd src/rust-wasm + rustup target add wasm32-unknown-unknown + cargo install wasm-pack + wasm-pack build --target web + ``` + +4. Webサーバーを起動します。 + + ```sh + cd ../.. + npm install + npm run dev + ``` + +5. [アプリケーション](http://localhost:5173/)にアクセスします。 このアプリケーションページには2つのフレームがあります。1つはアリスのユーザーインターフェース用、もう1つはビルのユーザーインターフェース用です。 2つのフレームは通信しません。便宜上、同じページにあるだけです。 + +6. アリスとして、**ステルス・メタアドレスを生成**をクリックします。 これにより、新しいステルスアドレスと対応する秘密鍵が表示されます。 ステルス・メタアドレスをクリップボードにコピーします。 + +7. ビルとして、新しいステルス・メタアドレスを貼り付け、**アドレスを生成**をクリックします。 これにより、アリスに資金を送るためのアドレスが表示されます。 + +8. アドレスとビルの公開鍵をコピーし、アリスのユーザーインターフェースの「ビルによって生成されたアドレスの秘密鍵」エリアに貼り付けます。 これらのフィールドに入力すると、そのアドレスの資産にアクセスするための秘密鍵が表示されます。 + +9. [オンライン計算機](https://iancoleman.net/ethereum-private-key-to-address/)を使用して、秘密鍵がアドレスに対応していることを確認できます。 + +### プログラムの仕組み {#how-the-program-works} + +#### WASMコンポーネント {#wasm} + +WASMにコンパイルされるソースコードは[Rust](https://rust-lang.org/)で書かれています。 [`src/rust_wasm/src/lib.rs`](https://github.com/qbzzt/251022-stealth-addresses/blob/main/src/rust-wasm/src/lib.rs)で確認できます。 このコードは主に、JavaScriptコードと[`eth-stealth-addresses`ライブラリ](https://github.com/kassandraoftroy/eth-stealth-addresses)間のインターフェースです。 + +**`Cargo.toml`** + +Rustにおける[`Cargo.toml`](https://doc.rust-lang.org/cargo/reference/manifest.html)は、JavaScriptの[`package.json`](https://docs.npmjs.com/cli/v9/configuring-npm/package-json)に類似しています。 パッケージ情報、依存関係の宣言などが含まれています。 + +```toml +[package] +name = "rust-wasm" +version = "0.1.0" +edition = "2024" + +[dependencies] +eth-stealth-addresses = "0.1.0" +hex = "0.4.3" +wasm-bindgen = "0.2.104" +getrandom = { version = "0.2", features = ["js"] } +``` + +[`getrandom`](https://docs.rs/getrandom/latest/getrandom/)パッケージは、乱数を生成する必要があります。 それは純粋なアルゴリズム的手法では実行できません。エントロピーの源として物理的なプロセスへのアクセスが必要です。 この定義は、実行中のブラウザに問い合わせることで、そのエントロピーを取得することを指定します。 + +```toml +console_error_panic_hook = "0.1.7" +``` + +[このライブラリ](https://docs.rs/console_error_panic_hook/latest/console_error_panic_hook/)は、WASMコードがパニックを起こして続行できなくなったときに、より意味のあるエラーメッセージを提供します。 + +```toml +[lib] +crate-type = ["cdylib", "rlib"] +``` + +WASMコードを生成するために必要な出力タイプです。 + +**`lib.rs`** + +これが実際のRustコードです。 + +```rust +use wasm_bindgen::prelude::*; +``` + +RustからWASMパッケージを作成するための定義です。 それらは[ここ](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/index.html)で文書化されています。 + +```rust +use eth_stealth_addresses::{ + generate_stealth_meta_address, + generate_stealth_address, + compute_stealth_key +}; +``` + +[`eth-stealth-addresses` ライブラリ](https://github.com/kassandraoftroy/eth-stealth-addresses)から必要な関数です。 + +```rust +use hex::{decode,encode}; +``` + +Rustは通常、値にバイト[配列](https://doc.rust-lang.org/std/primitive.array.html) (`[u8; ]`) を使用します。 しかし、JavaScriptでは、通常16進数文字列を使用します。 [`hex`ライブラリ](https://docs.rs/hex/latest/hex/)は、ある表現から別の表現へと変換してくれます。 + +```rust +#[wasm_bindgen] +``` + +JavaScriptからこの関数を呼び出すことができるように、WASMバインディングを生成します。 + +```rust +pub fn wasm_generate_stealth_meta_address() -> String { +``` + +複数のフィールドを持つオブジェクトを返す最も簡単な方法は、JSON文字列を返すことです。 + +```rust + let (address, spend_private_key, view_private_key) = + generate_stealth_meta_address(); +``` + +[`generate_stealth_meta_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_meta_address.html)は3つのフィールドを返します: + +- メタアドレス(_Kpub_ と _Vpub_) +- 閲覧用秘密鍵(_Vpriv_) +- 支払い用秘密鍵(_Kpriv_) + +[タプル](https://doc.rust-lang.org/std/primitive.tuple.html)構文を使用すると、これらの値を再度分離できます。 + +```rust + format!("{{\"address\":\"{}\",\"view_private_key\":\"{}\",\"spend_private_key\":\"{}\"}}", + encode(address), + encode(view_private_key), + encode(spend_private_key) + ) +} +``` + +[`format!`](https://doc.rust-lang.org/std/fmt/index.html)マクロを使用して、JSONエンコードされた文字列を生成します。 [`hex::encode`](https://docs.rs/hex/latest/hex/fn.encode.html)を使用して、配列を16進数文字列に変更します。 + +```rust +fn str_to_array(s: &str) -> Option<[u8; N]> { +``` + +この関数は、(JavaScriptから提供された) 16進数文字列をバイト配列に変換します。 JavaScriptコードから提供された値を解析するために使用します。 この関数は、Rustが配列とベクターをどのように扱うかによって複雑になっています。 + +``という式は[ジェネリック](https://doc.rust-lang.org/book/ch10-01-syntax.html)と呼ばれます。 `N` は返される配列の長さを制御するパラメータです。 この関数は実際には`str_to_array::`として呼び出され、`n`は配列の長さです。 + +戻り値は `Option<[u8; N]>` であり、これは返される配列が[オプショナル](https://doc.rust-lang.org/std/option/)であることを意味します。 これは、失敗する可能性のある関数に対するRustの典型的なパターンです。 + +例えば、`str_to_array::10("bad060a7")`を呼び出すと、関数は10個の値を持つ配列を返すはずですが、入力は4バイトしかありません。 関数は失敗する必要があり、`None`を返すことでそれを行います。 `str_to_array::4("bad060a7")`の戻り値は `Some<[0xba, 0xd0, 0x60, 0xa7]>` になります。 + +```rust + // decodeはResult, _>を返す + let vec = decode(s).ok()?; +``` + +[`hex::decode`](https://docs.rs/hex/latest/hex/fn.decode.html)関数は`Result, FromHexError>`を返します。 [`Result`](https://doc.rust-lang.org/std/result/)型には、成功した結果 (`Ok(value)`) またはエラー (`Err(error)`) のいずれかが含まれます。 + +`.ok()`メソッドは`Result`を`Option`に変換し、その値は成功した場合は`Ok()`の値、そうでなければ`None`になります。 最後に、[疑問符演算子](https://doc.rust-lang.org/std/option/#the-question-mark-operator-)は、`Option`が空の場合に現在の関数を中止し、`None`を返します。 そうでなければ、値をアンラップしてそれを返します (この場合、`vec`に値を割り当てます)。 + +これは奇妙で複雑なエラー処理方法に見えるかもしれませんが、`Result`と`Option`は、すべてのエラーが何らかの方法で処理されることを保証します。 + +```rust + if vec.len() != N { return None; } +``` + +バイト数が正しくない場合は失敗であり、`None`を返します。 + +```rust + // try_intoはvecを消費し、[u8; N]を作成しようと試みる + let array: [u8; N] = vec.try_into().ok()?; +``` + +Rustには2つの配列型があります。 [配列](https://doc.rust-lang.org/std/primitive.array.html)は固定サイズです。 [ベクター](https://doc.rust-lang.org/std/vec/index.html)は大きくなったり小さくなったりできます。 `hex::decode`はベクターを返しますが、`eth_stealth_addresses`ライブラリは配列を受け取ることを期待しています。 [`.try_into()`](https://doc.rust-lang.org/std/convert/trait.TryInto.html#required-methods)は、値を別の型、たとえばベクターを配列に変換します。 + +```rust + Some(array) +} +``` + +Rustでは、関数の最後で値を返す際に[`return`](https://doc.rust-lang.org/std/keyword.return.html)キーワードを使用する必要はありません。 + +```rust +#[wasm_bindgen] +pub fn wasm_generate_stealth_address(stealth_address: &str) -> Option { +``` + +この関数は、_Vpub_ と _Kpub_ の両方を含む公開メタアドレスを受け取ります。 これは、ステルスアドレス、公開する公開鍵 (_Rpub_)、および公開されたアドレスのうちどれがアリスに属する可能性があるかを特定する速度を上げる1バイトのスキャン値を返します。 + +スキャン値は共有シークレット (_S = GRprivVpriv_) の一部です。 この値はアリスが利用でき、これを確認する方が _f(Kpub+G\*hash(S))_ が公開されたアドレスと等しいかどうかを確認するよりもはるかに高速です。 + +```rust + let (address, r_pub, scan) = + generate_stealth_address(&str_to_array::<66>(stealth_address)?); +``` + +ライブラリの[`generate_stealth_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_address.html)を使用します。 + +```rust + format!("{{\"address\":\"{}\",\"rPub\":\"{}\",\"scan\":\"{}\"}}", + encode(address), + encode(r_pub), + encode(&[scan]) + ).into() +} +``` + +JSONエンコードされた出力文字列を準備します。 + +```rust +#[wasm_bindgen] +pub fn wasm_compute_stealth_key( + address: &str, + bill_pub_key: &str, + view_private_key: &str, + spend_private_key: &str +) -> Option { + . + . + . +} +``` + +この関数は、ライブラリの[`compute_stealth_key`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.compute_stealth_key.html)を使用して、アドレスから引き出すための秘密鍵(_Rpriv_)を計算します。 この計算には以下の値が必要です: + +- アドレス (_Address=f(Ppub)_) +- ビルによって生成された公開鍵(_Rpub_) +- 閲覧用秘密鍵(_Vpriv_) +- 支払い用秘密鍵(_Kpriv_) + +```rust +#[wasm_bindgen(start)] +``` + +[`#[wasm_bindgen(start)]`](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/on-rust-exports/start.html)は、WASMコードが初期化されるときに関数が実行されることを指定します。 + +```rust +pub fn main() { + console_error_panic_hook::set_once(); +} +``` + +このコードは、パニック出力をJavaScriptコンソールに送信することを指定します。 動作を確認するには、アプリケーションを使用し、ビルに無効なメタアドレスを与えます (16進数の1桁を変更するだけ)。 JavaScriptコンソールに次のエラーが表示されます: + +``` +rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/subtle-2.6.1/src/lib.rs:701:9: +assertion `left == right` failed + left: 0 + right: 1 +``` + +続いてスタックトレースが表示されます。 次に、ビルに有効なメタアドレスを与え、アリスには無効なアドレスまたは無効な公開鍵のいずれかを与えます。 次のエラーが表示されます: + +``` +rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/eth-stealth-addresses-0.1.0/src/lib.rs:78:9: +keys do not generate stealth address +``` + +再び、スタックトレースが続きます。 + +#### ユーザーインターフェース {#ui} + +ユーザーインターフェースは[React](https://react.dev/)を使用して書かれ、[Vite](https://vite.dev/)によって提供されます。 これらについては、[このチュートリアル](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/)で学ぶことができます。 ここでは、ブロックチェーンやウォレットと直接対話しないため、[WAGMI](https://wagmi.sh/)は必要ありません。 + +ユーザーインターフェースで唯一自明でない部分は、WASMの接続性です。 その仕組みは次のとおりです。 + +**`vite.config.js`** + +このファイルには[Viteの設定](https://vite.dev/config/)が含まれています。 + +```js +import { defineConfig } from 'vite' +import react from '@vitejs/plugin-react' +import wasm from "vite-plugin-wasm"; + +// https://vite.dev/config/ +export default defineConfig({ + plugins: [react(), wasm()], +}) +``` + +2つのViteプラグインが必要です: [react](https://www.npmjs.com/package/@vitejs/plugin-react)と[wasm](https://github.com/Menci/vite-plugin-wasm#readme)。 + +**`App.jsx`** + +このファイルは、アプリケーションのメインコンポーネントです。 これは、`Alice`と`Bill`という2つのコンポーネントを含むコンテナで、これらのユーザーのユーザーインターフェースです。 WASMに関連する部分は初期化コードです。 + +```jsx +import init from './rust-wasm/pkg/rust_wasm.js' +``` + +[`wasm-pack`](https://rustwasm.github.io/docs/wasm-pack/)を使用すると、ここで使用する2つのファイルが作成されます。1つは実際のコードを含むwasmファイル (ここでは`src/rust-wasm/pkg/rust_wasm_bg.wasm`)、もう1つはそれを使用するための定義を含むJavaScriptファイル (ここでは`src/rust_wasm/pkg/rust_wasm.js`)です。 そのJavaScriptファイルのデフォルトエクスポートは、WASMを初期化するために実行する必要があるコードです。 + +```jsx +function App() { + . + . + . + useEffect(() => { + const loadWasm = async () => { + try { + await init(); + setWasmReady(true) + } catch (err) { + console.error('Error loading wasm:', err) + alert("Wasm error: " + err) + } + } + + loadWasm() + }, [] + ) +``` + +[`useEffect`フック](https://react.dev/reference/react/useEffect)を使用すると、状態変数が変更されたときに実行される関数を指定できます。 ここでは、状態変数のリストが空 (`[]`) なので、この関数はページが読み込まれたときに一度だけ実行されます。 + +エフェクト関数はすぐに戻る必要があります。 WASM `init` (これは`.wasm`ファイルをロードする必要があるため時間がかかります) のような非同期コードを使用するために、内部で[`async`](https://en.wikipedia.org/wiki/Async/await)関数を定義し、`await`なしで実行します。 + +**`Bill.jsx`** + +これはビルのユーザーインターフェースです。 アリスから提供されたステルス・メタアドレスに基づいてアドレスを作成するという単一のアクションがあります。 + +```jsx +import { wasm_generate_stealth_address } from './rust-wasm/pkg/rust_wasm.js' +``` + +デフォルトのエクスポートに加えて、`wasm-pack`によって生成されたJavaScriptコードは、WASMコードのすべての関数に対応する関数をエクスポートします。 + +```jsx + { + setPublicAddress(JSON.parse(wasm_generate_stealth_address(stealthMetaAddress))) + }}> +``` + +`wasm-pack`によって作成されたJavaScriptファイルからエクスポートされた関数を呼び出すだけで、WASM関数を呼び出すことができます。 + +**`Alice.jsx`** + +`Alice.jsx`のコードも同様ですが、アリスには2つのアクションがあります。 + +- メタアドレスを生成する +- ビルによって公開されたアドレスの秘密鍵を取得する + +## 結論 {#conclusion} + +ステルスアドレスは万能薬ではありません。[正しく使用する](#go-wrong)必要があります。 しかし、正しく使用すれば、公開ブロックチェーン上でプライバシーを確保することができます。 + +[私の他の作品はこちらでご覧いただけます](https://cryptodocguy.pro/). \ No newline at end of file diff --git a/public/content/translations/ja/developers/tutorials/testing-erc-20-tokens-with-waffle/index.md b/public/content/translations/ja/developers/tutorials/testing-erc-20-tokens-with-waffle/index.md index a9253baaaf6..be94fd1c2f8 100644 --- a/public/content/translations/ja/developers/tutorials/testing-erc-20-tokens-with-waffle/index.md +++ b/public/content/translations/ja/developers/tutorials/testing-erc-20-tokens-with-waffle/index.md @@ -1,6 +1,6 @@ --- -title: Waffleを使って、ERC-20トークンをテストする -description: Waffleを使用して、Solidityで書かれたスマートコントラクトをテストしたり、スマートコントラクトのマッチャーを使用する方法について学ぶ。 +title: "Waffleを使って、ERC-20トークンをテストする" +description: "Waffleを使用して、Solidityで書かれたスマートコントラクトをテストしたり、スマートコントラクトのマッチャーを使用する方法について学ぶ。" author: Vladislav Starostenko tags: - "Waffle" diff --git a/public/content/translations/ja/developers/tutorials/testing-smart-contract-with-waffle/index.md b/public/content/translations/ja/developers/tutorials/testing-smart-contract-with-waffle/index.md index 8d07a69140f..5656f8ad06e 100644 --- a/public/content/translations/ja/developers/tutorials/testing-smart-contract-with-waffle/index.md +++ b/public/content/translations/ja/developers/tutorials/testing-smart-contract-with-waffle/index.md @@ -1,6 +1,6 @@ --- -title: WaffleでERC-20トークンをテストする -description: Waffleを使って、Solidityで作成したスマートコントラクトをテストし、スマートコントラクトのマッチャーを使用する方法について学ぶ +title: "WaffleでERC-20トークンをテストする" +description: "Waffleを使って、Solidityで作成したスマートコントラクトをテストし、スマートコントラクトのマッチャーを使用する方法について学ぶ" author: Vladislav Starostenko tags: - "Waffle" diff --git a/public/content/translations/ja/developers/tutorials/the-graph-fixing-web3-data-querying/index.md b/public/content/translations/ja/developers/tutorials/the-graph-fixing-web3-data-querying/index.md index 313d5265f64..0ad713fd5db 100644 --- a/public/content/translations/ja/developers/tutorials/the-graph-fixing-web3-data-querying/index.md +++ b/public/content/translations/ja/developers/tutorials/the-graph-fixing-web3-data-querying/index.md @@ -1,26 +1,20 @@ --- -title: "The Graph: Web3データクエリ問題を解決" -description: ブロックチェーンは、SQLのないデータベースのようなものです。 すべてのデータはありますが、アクセスする方法がありません。 The GraphとGraphQLでこの問題を解決する方法をご紹介します。 +title: "The Graph: Web3データクエリ問題の解決" +description: "ブロックチェーンは、SQLのないデータベースのようなものです。 すべてのデータはありますが、アクセスする方法がありません。 The GraphとGraphQLでこの問題を解決する方法をご紹介します。" author: Markus Waas lang: ja -tags: - - "Solidity" - - "スマートコントラクト" - - "クエリ" - - "the graph" - - "create-eth-app" - - "react" +tags: ["solidity", "smart contracts", "querying", "the graph", "react"] skill: intermediate published: 2020-09-06 source: soliditydeveloper.com sourceUrl: https://soliditydeveloper.com/thegraph --- -今回は、The Graphについて詳しく見ていきます。The Grashは昨年、分散型アプリケーション(Dapp)を開発するために欠かせない標準スタックの一部となりました。 まずは、従来のやり方から見ていきましょう。 +今回は、The Graphを詳しく見ていきます。これは昨年、dappsを開発するための標準スタックの一部となりました。 まずは、従来のやり方から見ていきましょう... -## The Graphを使わない例 {#without-the-graph} +## The Graphを使用しない場合... {#without-the-graph} -それでは、説明のために簡単な例から始めます。 私たちは皆、ゲームが好きなので、ユーザーが賭けをする次の簡単なゲームを考えてみましょう。 +それでは、説明のために簡単な例を見ていきましょう。 私たちは皆ゲームが好きなので、ユーザーがベットするシンプルなゲームを想像してみましょう: ```solidity pragma solidity 0.7.1; @@ -35,7 +29,7 @@ contract Game { if (hasWon) { (bool success, ) = msg.sender.call{ value: msg.value * 2 }(''); - require(success, "Transfer failed"); + require(success, "送金に失敗しました"); totalGamesPlayerWon++; } else { totalGamesPlayerLost++; @@ -46,90 +40,90 @@ contract Game { } ``` -ここでは、分散型アプリケーション(Dapp)で合計賭金、合計勝敗数を表示し、誰かが再度プレイするたびに更新したいとします。 このアプローチは次のようになります。 +さて、私たちのdappで合計ベット数、勝敗の合計ゲーム数を表示し、誰かが再度プレイするたびにそれを更新したいとしましょう。 アプローチは次のようになります: -1. `totalGamesPlayerWon`の取得 -2. `totalGamesPlayerLost`の取得 -3. `BetPlaced`イベントのサブスクライブ +1. `totalGamesPlayerWon`を取得します。 +2. `totalGamesPlayerLost`を取得します。 +3. `BetPlaced`イベントをサブスクライブします。 -右に示したように[Web3イベント](https://docs.web3js.org/api/web3/class/Contract#events)をリッスンできますが、多くのケースを処理する必要があります。 +右に示すように[Web3のイベント](https://docs.web3js.org/api/web3/class/Contract#events)をリッスンできますが、かなりの数のケースを処理する必要があります。 ```solidity GameContract.events.BetPlaced({ fromBlock: 0 }, function(error, event) { console.log(event); }) .on('data', function(event) { - // event fired + // イベントが発火 }) .on('changed', function(event) { - // event was removed again + // イベントが再度削除された }) .on('error', function(error, receipt) { - // tx rejected + // トランザクションが拒否された }); ``` -ここでの簡単な例では、これはまだある程度は大丈夫のようです。 しかし今度は、現在のプレイヤーが賭けで失った金額と獲得した金額を表示したいとしましょう。 こうなると、運が悪いとしか言えません。これらの値の格納や取得を行う新しいコントラクトをデプロイした方が良いでしょう。 では、さらに複雑なスマートコントラクトと分散型アプリケーション(Dapp)を想像してみてください。あっという間に厄介な状況になります。 +この単純な例では、これでもまだある程度は問題ありません。 しかし、今度は現在のプレイヤーの勝敗ベット額のみを表示したいとしましょう。 残念ながら、それらの値を保存して取得する新しいコントラクトをデプロイするしかありません。 そして、はるかに複雑なスマートコントラクトとdappを想像してみてください。事態はすぐに厄介になる可能性があります。 - + -これが最適でないことは次のことからわかります。 +これが最適ではない理由は、以下の通りです: -- すでにデプロイ済みのコントラクトでは機能しないこと -- これらの値を格納するのに追加のガス代がかかること -- イーサリアムノードのデータを取得するのに別の呼び出しが必要なこと +- すでにデプロイ済みのコントラクトでは機能しない。 +- それらの値を保存するための追加のガス代。 +- イーサリアムノードのデータを取得するために、別の呼び出しが必要になる。 - + では、より良い解決策を見ていきましょう。 -## GraphQLの紹介 {#let-me-introduce-to-you-graphql} +## GraphQLのご紹介 {#let-me-introduce-to-you-graphql} -最初にGraphQLについて説明します。GraphQLは、もともとフェイスブック社によって設計され、実装されました。 従来のRest APIモデルについては、ご存知かもしれません。 では、今度は次のように必要なデータを正確に取得できるクエリを作成できると想像してみてください。 +まず、GraphQLについてお話ししましょう。これは元々Facebookによって設計・実装されたものです。 従来のREST APIモデルには馴染みがあるかもしれません。 代わりに、欲しいデータを正確に取得するためのクエリを書けると想像してみてください。 - + - + -2つの画像は、GraphQLの本質をほぼ捉えています。 右のクエリーでは、必要なデータを正確に定義できるので、1回のリクエストで必要なものだけを取得できます。 GraphQLサーバーは必要とされるすべてのデータの取得を処理できるので、フロントエンドのコンシューマ側にとっては極めて使いやすいツールとなっています。 ご興味があれば、サーバーが具体的にどのようにクエリを処理するかについて[わかりやすい説明](https://www.apollographql.com/blog/graphql-explained)をご覧ください。 +この2つの画像は、GraphQLの本質をよく捉えています。 右側のクエリでは、欲しいデータを正確に定義できます。そのため、1回のリクエストで必要なものだけをすべて取得できます。 GraphQLサーバーは必要なすべてのデータの取得を処理するため、フロントエンドの利用者側にとっては非常に使いやすくなっています。 ご興味があれば、[こちらの分かりやすい説明](https://www.apollographql.com/blog/graphql-explained)で、サーバーがクエリをどのように処理するかを正確に知ることができます。 -この知識をもとに、ブロックチェーン空間とThe Graphの世界に入って行きましょう。 +この知識をもとに、いよいよブロックチェーンとThe Graphの世界に飛び込んでみましょう。 -## The Graphとは {#what-is-the-graph} +## The Graphとは? {#what-is-the-graph} -ブロックチェーンは、分散型データベースですが、通常のデータベースとは対照的に、データベースに対するクエリ言語がありません。 データを取得することにおいては、苦痛を伴うか不可能かのどちらかです。 The Graphは、ブロックチェーンデータのインデックス作成とクエリを行うための分散型プロトコルです。 ご想像の通りThe Graphは、GraphQLをクエリ言語として使用しています。 +ブロックチェーンは分散型データベースですが、通常の場合とは対照的に、このデータベースにはクエリ言語がありません。 データを取得するためのソリューションは、手間がかかるか、あるいはまったく不可能です。 The Graphは、ブロックチェーンのデータをインデックス化し、クエリを実行するための分散型プロトコルです。 お察しの通り、クエリ言語としてGraphQLを使用しています。  -何かを理解するには例を見るのが最善なので、先ほどのGameContractでThe Graphを使ってみましょう。 +何かを理解するには例を見るのが一番です。そこで、私たちのGameContractの例でThe Graphを使ってみましょう。 ## サブグラフの作成方法 {#how-to-create-a-subgraph} -サブグラフは、データにインデックスを作成する方法を定義するものです。 定義には、次の3つのコンポーネントが必要です。 +データをインデックス化する方法の定義は、サブグラフと呼ばれます。 それには3つのコンポーネントが必要です: -1. マニフェスト(`subgraph.yaml`) -2. スキーマ(`schema.graphql`) -3. マッピング(`mapping.ts`) +1. マニフェスト (`subgraph.yaml`) +2. スキーマ (`schema.graphql`) +3. マッピング (`mapping.ts`) -### マニフェスト(`subgraph.yaml`) {#manifest} +### マニフェスト (`subgraph.yaml`) {#manifest} -マニフェストは設定ファイルであり、次のことを定義します。 +マニフェストは設定ファイルで、以下を定義します: -- どのスマートコントラクトにインデックスを作成するか(アドレス、ネットワーク、アプリケーションバイナリインターフェース(ABI)等) +- どのスマートコントラクトをインデックス化するか (アドレス、ネットワーク、ABIなど) - どのイベントをリッスンするか -- 関数呼び出しやブロックなど、その他に何をリッスンするか -- 呼び出されるマッピング関数 (後述の`mapping.ts`を参照) +- 関数呼び出しやブロックなど、他にリッスンするもの +- 呼び出されるマッピング関数 (下記の`mapping.ts`を参照) -マニフェストには複数のコントラクトとハンドラを定義できます。 典型的な設定では、またはHardhatプロジェクト内にサブグラフフォルダと独自のリポジトリがあります。 それにより、簡単にアプリケーションバイナリインターフェース(ABI)を参照することができます。 +ここでは複数のコントラクトとハンドラを定義できます。 典型的なセットアップでは、Hardhatプロジェクト内に独自のレポジトリを持つサブグラフフォルダを置きます。 そうすれば、ABIを簡単に参照できます。 -便利さの観点から、Mustacheのようなテンプレートツールを使用することもできます。 `subgraph.template.yaml`を作成し、最新のデプロイメントに基づいたアドレスを挿入します。 より高度な設定例については、[Aaveサブグラフリポジトリ](https://github.com/aave/aave-protocol/tree/master/thegraph)の例をご覧ください。 +利便性のために、Mustacheのようなテンプレートツールを使ってもよいでしょう。 次に、`subgraph.template.yaml`を作成し、最新のデプロイに基づいてアドレスを挿入します。 より高度なセットアップ例については、例えば[Aaveサブグラフリポジトリ](https://github.com/aave/aave-protocol/tree/master/thegraph)を参照してください。 -ドキュメント全文については、[こちら](https://thegraph.com/docs/en/developing/creating-a-subgraph/#the-subgraph-manifest)をご覧ください。 +完全なドキュメントは[こちら](https://thegraph.com/docs/en/developing/creating-a-subgraph/#the-subgraph-manifest)でご覧いただけます。 ```yaml specVersion: 0.0.1 -description: Placing Bets on Ethereum -repository: - GitHub link - +description: イーサリアム上でのベット +repository: - GitHubリンク - schema: file: ./schema.graphql dataSources: @@ -155,19 +149,19 @@ dataSources: file: ./src/mapping.ts ``` -### スキーマ(`schema.graphql`) {#schema} +### スキーマ (`schema.graphql`) {#schema} -スキーマは、GraphQLのデータ定義です。 必要なエンティティとタイプを定義することができます。 The Graphでサポートされているタイプは、次のとおりです。 +スキーマはGraphQLのデータ定義です。 これにより、どのエンティティが存在し、その型は何かを定義できます。 The Graphでサポートされている型は次の通りです -- バイト型 -- ID型 -- 文字列型 -- ブール型 -- 整数型 -- BigInt型 -- BigDecimal型 +- バイト +- ID +- String +- Boolean +- Int +- BigInt +- BigDecimal -リレーションシップを定義するために、エンティティをタイプとして使用することもできます。 この例では、プレイヤーと賭け(Bet)で1対多のリレーションシップを定義します。 「!」 は、空の値を取れないこと意味します。 完全なドキュメントは、[こちら](https://thegraph.com/docs/en/developing/creating-a-subgraph/#the-subgraph-manifest)をご覧ください。 +エンティティを型として使用して、リレーションシップを定義することもできます。 この例では、プレイヤーからベットへの1対多のリレーションシップを定義します。 ! は値が空にできないことを意味します。 完全なドキュメントは[こちら](https://thegraph.com/docs/en/developing/creating-a-subgraph/#the-subgraph-manifest)でご覧いただけます。 ```graphql type Bet @entity { @@ -186,17 +180,17 @@ type Player @entity { } ``` -### マッピング(`mapping.ts`) {#mapping} +### マッピング (`mapping.ts`) {#mapping} -The Graphのマッピングファイルは、受信したイベントをエンティティに変換する関数を定義します。 TypescriptのサブセットであるAssemblyScriptで書きます。 これは、より効率化され、よりポータブル化されたマッピングの実行を実現するため、WebAssembly(WASM)にコンパイルされます。 +The Graphのマッピングファイルは、受信したイベントをエンティティに変換する関数を定義します。 これはTypescriptのサブセットであるAssemblyScriptで書かれています。 これは、マッピングの実行をより効率的でポータブルにするために、WASM (WebAssembly) にコンパイルできることを意味します。 -各関数を`subgraph.yaml`ファイルに定義する必要があります。この例では、`handleNewBet`の一つだけが必要です。 まず、idとして送信者アドレスからPlayerエンティティを読み込もうとします。 存在しない場合は、新しいエンティティを作成して開始値を入れます。 +`subgraph.yaml`ファイルで名付けられた各関数を定義する必要があります。この例では、`handleNewBet`の1つだけが必要です。 まず、送信者のアドレスをIDとしてPlayerエンティティをロードしようとします。 それが存在しない場合は、新しいエンティティを作成し、初期値を入力します。 -次に、Betエンティティを作成します。 idは、`event.transaction.hash.toHex() + "-" + event.logIndex.toString()`になり、常に一意の値になります。 誰かがスマートコントラクトを介して1つのトランザクションでplaceBet関数を複数回呼び出す可能性があるため、ハッシュのみの使用では十分ではありません。 +次に、新しいBetエンティティを作成します。 このIDは `event.transaction.hash.toHex() + "-" + event.logIndex.toString()` となり、常に一意の値を保証します。 スマートコントラクトを介して1つのトランザクションで誰かがplaceBet関数を複数回呼び出す可能性があるため、ハッシュのみでは不十分です。 -最後に、すべてのデータでPlayerエンティティを更新します。 配列を直接プッシュすることはできませんが、ここに示すように更新する必要があります。 betを参照するためにidを使用します。 エンティティを保存するには、`.save()`が最後に必要です。 +最後に、すべてのデータでPlayerエンティティを更新できます。 配列に直接プッシュすることはできませんが、ここに示すように更新する必要があります。 ベットを参照するためにIDを使用します。 そして、エンティティを保存するためには最後に `.save()` が必要です。 -ドキュメント全文については、こちらをご覧ください。https://thegraph.com/docs/en/developing/creating-a-subgraph/#writing-mappings マッピングファイルにログの出力を追加できます。詳細は[こちら](https://thegraph.com/docs/en/subgraphs/developing/creating/graph-ts/api/#api-reference)をご覧ください。 +完全なドキュメントは[こちら](https://thegraph.com/docs/en/developing/creating-a-subgraph/#writing-mappings)でご覧いただけます。 マッピングファイルにログ出力を追加することもできます。[こちら](https://thegraph.com/docs/en/subgraphs/developing/creating/graph-ts/api/#api-reference)を参照してください。 ```typescript import { Bet, Player } from "../generated/schema" @@ -206,7 +200,7 @@ export function handleNewBet(event: PlacedBet): void { let player = Player.load(event.transaction.from.toHex()) if (player == null) { - // create if doesn't exist yet + // まだ存在しない場合は作成 player = new Player(event.transaction.from.toHex()) player.bets = new Array(0) player.totalPlayedCount = 0 @@ -229,7 +223,7 @@ export function handleNewBet(event: PlacedBet): void { player.hasLostCount++ } - // update array like this + // このように配列を更新 let bets = player.bets bets.push(bet.id) player.bets = bets @@ -240,7 +234,7 @@ export function handleNewBet(event: PlacedBet): void { ## フロントエンドでの使用 {#using-it-in-the-frontend} -Apollo Boostなどを使うと、The GraphをReact(またはApollo-Vue)の分散型アプリケーション(Dapp)に簡単に統合できます。 特にReactフックとApolloを使用する場合は、コンポーネントに単一のGraphQLクエリを記述するのと同じくらいデータの取得が簡単です。 典型的な設定は次のようになります。 +Apollo Boostのようなものを使用すると、React dapp (またはApollo-Vue) にThe Graphを簡単に統合できます。 特にReactフックとApolloを使用する場合、データの取得はコンポーネントに単一のGraphQLクエリを記述するのと同じくらい簡単です。 典型的な設定は次のようになります。 ```javascript // See all subgraphs: https://thegraph.com/explorer/ @@ -256,13 +250,13 @@ ReactDOM.render( ) ``` -例えば、下記のようなクエリを書くことができます。 これで以下の情報を取得できます。 +そして今、例えばこのようなクエリを書くことができます。 これにより、以下が取得されます -- 現在のユーザーの勝利数 -- 現在のユーザーの敗北数 -- 過去の賭けのタイムスタンプのリスト +- 現在のユーザーが勝った回数 +- 現在のユーザーが負けた回数 +- 彼の過去のすべてのベットのタイムスタンプのリスト -GraphQLサーバーへの単一リクエストですべて取得できます。 +すべてGraphQLサーバーへの単一のリクエストで完了します。 ```javascript const myGraphQlQuery = gql` @@ -285,29 +279,29 @@ React.useEffect(() => { }, [loading, error, data]) ``` - + -しかし、最後のパズルの1つが欠けています。それがサーバーについてです。 自分のノードでサーバーを実行することも、ホストサービスを使用することもできます。 +しかし、パズルの最後のピース、つまりサーバーが欠けています。 自分で実行するか、ホストされたサービスを使用することができます。 ## The Graphサーバー {#the-graph-server} -### Graph エクスプローラー: ホストサービス {#graph-explorer-the-hosted-service} +### Graph Explorer: ホストされたサービス {#graph-explorer-the-hosted-service} -最も簡単な方法は、ホストサービスを利用することです。 [こちらの手順](https://thegraph.com/docs/en/deploying/deploying-a-subgraph-to-hosted/)に従ってサブグラフをデプロイしてください。 [エクスプローラー](https://thegraph.com/explorer/)では、さまざまなプロジェクト向けに既存のサブグラフを探すことができます。 +最も簡単な方法は、ホストされたサービスを使用することです。 サブグラフをデプロイするには、[こちら](https://thegraph.com/docs/en/deploying/deploying-a-subgraph-to-hosted/)の指示に従ってください。 多くのプロジェクトでは、実際に[エクスプローラー](https://thegraph.com/explorer/)で既存のサブグラフを見つけることができます。 - + -### 自分のノードで実行 {#running-your-own-node} +### 独自のノードの実行 {#running-your-own-node} -自分のノードでも実行できます。 実行方法については、[こちら](https://github.com/graphprotocol/graph-node#quick-start)のドキュメントをご覧ください。 これにより、ホストサービスでサポートされていないネットワークでも使用できます。 現在サポートしているネットワークについては、[こちら](https://thegraph.com/docs/en/developing/supported-networks/)をご覧ください。 +あるいは、独自のノードを実行することもできます。 ドキュメントは[こちら](https://github.com/graphprotocol/graph-node#quick-start)。 これを行う理由の1つは、ホストされたサービスでサポートされていないネットワークを使用する場合かもしれません。 現在サポートされているネットワークは[こちら](https://thegraph.com/docs/en/developing/supported-networks/)で確認できます。 -## 非中央集権型の未来 {#the-decentralized-future} +## 分散型の未来 {#the-decentralized-future} -GraphQLは、新しく受信するイベントのストリームもサポートしています。 これらの機能は、現在オープンベータ版の[Substreams](https://thegraph.com/docs/en/substreams/)を通して、グラフ上でサポートされています。 +GraphQLは、新たに着信するイベントのストリームもサポートしています。 これらは、現在オープンベータ版である[Substreams](https://thegraph.com/docs/en/substreams/) を介してグラフ上でサポートされています。 -[2021](https://thegraph.com/blog/mainnet-migration/)年に、The Graphは分散型インデックスネットワークへの移行を開始しました。 分散型インデックスネットワークのアーキテクチャの詳細については、[こちら](https://thegraph.com/docs/en/network/explorer/)をご覧ください。 +[2021年](https://thegraph.com/blog/mainnet-migration/)、The Graphは分散型インデックスネットワークへの移行を開始しました。 この分散型インデックスネットワークのアーキテクチャについては、[こちら](https://thegraph.com/docs/en/network/explorer/)で詳しく読むことができます。 -次の2つの重要な点があります。 +2つの重要な側面は次のとおりです。 -1. ユーザーは、クエリのインデックス作成者に料金を支払う。 -2. インデックス作成者は、グラフトークン(GRT)をステーキングする。 +1. ユーザーはクエリに対してインデクサーに支払います。 +2. インデクサーはグラフトークン (GRT) をステークします。 diff --git a/public/content/translations/ja/developers/tutorials/token-integration-checklist/index.md b/public/content/translations/ja/developers/tutorials/token-integration-checklist/index.md index 87176cedee9..1a2a4ece26a 100644 --- a/public/content/translations/ja/developers/tutorials/token-integration-checklist/index.md +++ b/public/content/translations/ja/developers/tutorials/token-integration-checklist/index.md @@ -1,84 +1,80 @@ --- -title: トークンを統合する際のチェックリスト -description: トークンとやり取りをする際の考慮事項のチェックリスト +title: "トークン統合チェックリスト" +description: "トークンとやり取りをする際の考慮事項のチェックリスト" author: "Trailofbits" lang: ja -tags: - - "Solidity" - - "スマートコントラクト" - - "セキュリティ" - - "トークン" +tags: ["solidity", "smart contracts", "security", "tokens"] skill: intermediate published: 2020-08-13 -source: セキュアなコントラクトの構築 +source: Building secure contracts sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/token_integration.md --- 任意のトークンとやり取りするときは、このチェックリストに従ってください。 各アイテムに関連したリスクを確実に理解し、ルールを遵守しない場合はその根拠を明確にしてください。 -幸いなことに、Slitherのすべての[ユーティリティ](https://github.com/crytic/slither#tools)は、トークンアドレス上で直接実行可能です: +便利なことに、Slitherのすべての[ユーティリティ](https://github.com/crytic/slither#tools)は、トークンアドレス上で直接実行できます。例えば: -[Slitherのチュートリアルを利用する](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/) +[Slitherの使い方チュートリアル](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/) ```bash slither-check-erc 0xdac17f958d2ee523a2206206994597c13d831ec7 TetherToken ``` -このチェックリストを利用する際には、Slitherを使って、当該トークンから以下を出力しておくとよいでしょう: +このチェックリストに従うには、対象トークンについてSlitherから以下の出力を取得しておくと便利です: ```bash - slither-check-erc [target] [contractName] [optional: --erc ERC_NUMBER] - slither [target] --print human-summary - slither [target] --print contract-summary -- slither-prop . --contract ContractName # requires configuration, and use of Echidna and Manticore +- slither-prop . --contract ContractName # 設定と、EchidnaおよびManticoreの使用が必要 ``` -## 全般的な考慮事項 {#general-considerations} +## 一般的な考慮事項 {#general-considerations} -- **セキュリティレビューを実行済みのコントラクトであること**。セキュリティレビューを経ていないコントラクトとは、やりとりしないでください。 セキュリティレビューでは、アセスメント期間(「Level of Effort」と呼ぶ場合もある) 、セキュリティ企業の評判、発見された件数および深刻度を確認してください。 -- **デベロッパに問い合わせられること**。インシデントが発生した場合、開発チームにアラートを提供する必要があるかもしれません。 [blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts)で、適切な問合せ先を確認してください。 -- **重要なアナウンスを行うセキュリティ関連のメーリングリストがあること**。重大な問題の発生時やアップグレード時に、あなたのようなユーザーに助言が提供される体制が整っているかを確認してください。 +- \*\*コントラクトがセキュリティレビューを受けていること。\*\*セキュリティレビューを受けていないコントラクトとのやり取りは避けてください。 評価の期間(「level of effort」とも呼ばれます)、セキュリティ企業の評判、検出事項の数と深刻度を確認してください。 +- \*\*開発者に連絡が取れること。\*\*インシデント発生時に、開発チームに警告する必要が生じる場合があります。 [blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts)で適切な連絡先を探してください。 +- \*\*重要な発表のためのセキュリティメーリングリストがあること。\*\*開発チームは(あなたのような!)ユーザーに対して、 重大な問題が発見された場合やアップグレードが行われる際に、助言を行うべきです。 -## ERC適合性 {#erc-conformity} +## ERCへの準拠 {#erc-conformity} -Slitherに含まれる[slither-check-erc](https://github.com/crytic/slither/wiki/ERC-Conformance)ユーティリティで、関連する多くのERC標準に対するトークンの遵守度をレビューできます。 slither-check-ercを次の内容の評価に使用してください。 +Slitherには、関連する多くのERC標準に対するトークンの準拠性をレビューする[slither-check-erc](https://github.com/crytic/slither/wiki/ERC-Conformance)というユーティリティが含まれています。 slither-check-ercを使用して、以下を確認してください: -- **TransferとtransferFromがブール値を返すこと**。トークンによっては、これらの関数でブール値を返さない場合があります。 その結果、コントラクトの呼び出しが実行できない場合があります。 -- **name、decimals、symbol関数を使用する場合、それらの関数が存在すること。**ERC-20標準ではこれらの関数はオプションであるため、コントラクトに含まれない場合があります。 -- **Decimalsがuint8値を返すこと**。トークンによっては、不適切であるunit256値を返す場合があります。 この場合は、戻り値が255未満になるように変更します。 -- **トークンが、既知の[ERC-20競合状態](https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729)を軽減すること**。ERC-20標準には既知のERC-20競合状態が存在するため、攻撃者がトークンを盗むのを防ぐためにこれを軽減する必要があります。 -- **トークンがERC-777トークンではなく、transferやtransferFromによる外部からの関数呼び出しを含まないこと**。transfer関数を使った外部からの呼び出しは、リエントランシー攻撃につながりかねません。 +- \*\*TransferおよびtransferFromがブール値を返すこと。\*\*一部のトークンは、これらの関数でブール値を返しません。 その結果、コントラクト内でのこれらの関数の呼び出しが失敗する可能性があります。 +- \*\*name、decimals、symbol関数が使用される場合、それらが存在すること。\*\*これらの関数はERC20標準では任意であり、存在しない場合があります。 +- \*\*decimalsがuint8を返すこと。\*\*一部のトークンは誤ってuint256を返します。 その場合は、返される値が255未満であることを確認してください。 +- \*\*トークンが既知の[ERC20競合状態](https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729)を軽減していること。\*\*ERC20標準には既知のERC20競合状態があり、攻撃者によるトークンの盗難を防ぐために軽減する必要があります。 +- \*\*トークンがERC777トークンではなく、transferおよびtransferFromに外部関数呼び出しがないこと。\*\*transfer関数内の外部呼び出しは、リエントランシーにつながる可能性があります。 -Slitherには[slither-prop](https://github.com/crytic/slither/wiki/Property-generation)というユーティリティが含まれており、ERCで頻繁に発生する欠陥の多くを発見するための単体テストとセキュリティ関連のプロパティを生成することができます。 slither-propを次の内容の評価に使用してください。 +Slitherには、多くの一般的なERCの欠陥を発見できる単体テストやセキュリティプロパティを生成するユーティリティ、[slither-prop](https://github.com/crytic/slither/wiki/Property-generation)が含まれています。 slither-propを使用して、以下を確認してください: -- **コントラクトがslither-propのすべての単体テストとセキュリティプロパティに合格すること**。 生成された単体テストを実行し、[Echidna](https://github.com/crytic/echidna)と[Manticore](https://manticore.readthedocs.io/en/latest/verifier.html)でプロパティを確認します。 +- \*\*コントラクトがslither-propのすべての単体テストとセキュリティプロパティに合格すること。\*\*生成された単体テストを実行し、[Echidna](https://github.com/crytic/echidna)と[Manticore](https://manticore.readthedocs.io/en/latest/verifier.html)でプロパティをチェックしてください。 -最後に、自動による特定が困難な一部の特徴について検討します。 以下の条件が発生していないか、マニュアルで確認してください: +最後に、自動的に特定することが困難な特性がいくつかあります。 以下の条件を手動でレビューしてください: -- **TransferおよびtransferFromがフィーを取らないこと**。デフレトークンは、予期せぬ動作を引き起こす可能性があります。 -- **トークンから得られる潜在的な利子収入が考慮されていること**。一部のトークンは、トークン保有者に利子を分配します。 この点を考慮しない場合、利子がコントラクト内でトラップされる可能性があります。 +- \*\*TransferおよびtransferFromで手数料が取られないこと。\*\*デフレトークンは、予期せぬ動作につながる可能性があります。 +- \*\*トークンから得られる潜在的な利子が考慮されていること。\*\*一部のトークンは、トークン保有者に利子を分配します。 考慮されていない場合、この利子がコントラクト内にトラップされてしまう可能性があります。 ## コントラクトの構成 {#contract-composition} -- **コントラクトが必要以上に複雑になっていないか**。 トークンは、シンプルなコントラクトでなければなりません。コードが複雑になればなるほど、よりレビューが煩雑になります。 複雑なコードを特定するには、Slitherの[human-summaryプリンター](https://github.com/crytic/slither/wiki/Printer-documentation#human-summary)を使用してください。 -- **コントラクトがSafeMathを使用しているか**。SafeMathを使用していないコントラクトは、より厳格なレビュー基準が必要になります。 コントラクトでSafeMathが使用されているかどうか、マニュアルで確認してください。 -- **トークンに関連しない関数の数が、最低限に抑えられているか**。 トークンに関連しない関数は、コントラクトにおいて問題が発生する可能性を高めてしまいます。 Slitherの [contract-summaryプリンター](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary)を使用して、コントラクトのコード全体をレビューしてください。 -- **トークンのアドレスが複数存在しないか**。残高更新のために複数のエントリーポイントを持つトークンは、当該アドレスに基づく内部の帳簿管理を毀損する可能性があります(例:`balances[token_address][msg.sender]`が実際の残高を反映しない場合)。 +- \*\*コントラクトが不要な複雑性を避けていること。\*\*トークンはシンプルなコントラクトであるべきです。複雑なコードを持つトークンは、より高い水準のレビューを必要とします。 Slitherの[human-summary printer](https://github.com/crytic/slither/wiki/Printer-documentation#human-summary)を使用して、複雑なコードを特定してください。 +- \*\*コントラクトがSafeMathを使用していること。\*\*SafeMathを使用していないコントラクトは、より高い水準のレビューを必要とします。 SafeMathが使用されているか、コントラクトを手動で検査してください。 +- \*\*コントラクトにトークン関連以外の関数がほとんどないこと。\*\*トークン関連以外の関数は、コントラクトで問題が発生する可能性を高めます。 Slitherの[contract-summary printer](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary)を使用して、コントラクトで使用されているコードを大まかにレビューしてください。 +- \*\*トークンがアドレスを1つしか持たないこと。\*\*残高更新のために複数のエントリーポイントを持つトークンは、アドレスに基づく内部の帳簿管理を壊す可能性があります(例: `balances[token_address][msg.sender]`が実際の残高を反映しなくなる)。 -## 所有者の特権 {#owner-privileges} +## 所有者の権限 {#owner-privileges} -- **トークンがアップグレード不可能であるか**。アップグレード可能なコントラクトは、時間の経過と共にルールが変更される可能性があります。 Slitherの[human-summaryプリンター](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary)を使用して、コントラクトがアップグレード可能かどうかを決定します。 -- **所有者のミント能力が制限されているか**。 悪意の所有者やセキュリティが侵害された所有者は、ミント能力を悪用する可能性があります。 Slitherの[human-summaryプリンター](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary)を使用して、ミント能力を評価し、マニュアルでコードをレビューする必要があるかを決定してください。 -- **トークンが、一時停止可能であるか**。 悪意の所有者やセキュリティを侵害された所有者は、一次停止が可能なトークンを利用してコントラクトをトラップすることが可能です。 マニュアルで、一時停止可能なコードを特定してください。 -- **所有者がコントラクトをブラックリストに登録できるようになっていないか**。 悪意の所有者やセキュリティが侵害された所有者は、ブラックリストに登録されたトークンを使用して、コントラクトをトラップすることが可能です。 マニュアルで、ブラックリスト機能を特定してください。 -- **トークン開発チームの身元がはっきりしており、不正使用の責任を負える組織であるか/strong>。匿名の開発チームが開発したコントラクトや、または法的シェルターの対象に含まれるコントラクトに対しては、より厳格なレビューが必要になります。 +- \*\*トークンがアップグレード不可能であること。\*\*アップグレード可能なコントラクトは、時間とともにルールが変更される可能性があります。 Slitherの[human-summary printer](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary)を使用して、コントラクトがアップグレード可能かどうかを判断してください。 +- \*\*所有者のミント能力が制限されていること。\*\*悪意のある、またはセキュリティを侵害された所有者は、ミント能力を悪用する可能性があります。 Slitherの[human-summary printer](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary)を使用してミント能力をレビューし、コードを手動でレビューすることも検討してください。 +- \*\*トークンが一時停止不可能であること。\*\*悪意のある、またはセキュリティを侵害された所有者は、一時停止可能なトークンに依存するコントラクトをトラップする可能性があります。 一時停止可能なコードを手動で特定してください。 +- \*\*所有者がコントラクトをブラックリストに登録できないこと。\*\*悪意のある、またはセキュリティを侵害された所有者は、ブラックリストを持つトークンに依存するコントラクトをトラップする可能性があります。 ブラックリスト機能を手動で特定してください。 +- \*\*トークンの背後にいるチームが既知であり、不正利用の責任を問えること。\*\*匿名の開発チームによるコントラクトや、法的保護区域にあるコントラクトは、より高い水準のレビューを必要とします。 -## トークンの枯渇 {#token-scarcity} +## トークンの希少性 {#token-scarcity} -トークンの枯渇に関わる問題については、マニュアルでレビューする必要があります。 以下の条件を確認してください: +トークンの希少性に関する問題のレビューには、手動でのレビューが必要です。 以下の条件を確認してください: -- **特定のユーザーが、トークン供給量の大部分を所有していないか**。少数のユーザーが大部分のトークンを所有する場合、トークンの再分配に基づき価格操作の可能性が発生します。 -- **総供給量は十分であるか**。総供給量が少ないトークンは、価格操作が容易になります。 -- **トークンが、複数の取引所に所在しているか**。 すべてのトークンが1カ所の取引所のみに存在する場合、この取引所のセキュリティが侵害されると、このトークンに依存するコントラクトが侵害される可能性があります。 -- **ユーザーは、多額の資金やフラッシュローンに関するリスクについて理解しているか**。トークン残高に依存するコントラクトは、多額の資金を持つ攻撃者やフラッシュローンを通じた攻撃について慎重に考慮する必要があります。 -- **トークンは、フラッシュミントが不可能であるか**。 フラッシュミンティングは、残高や総供給量を大幅に変更しうるため、トークンの運用において厳格かつ包括的なオーバーフローチェックが必要になります。 +- \*\*供給量の大部分を所有するユーザーがいないこと。\*\*少数のユーザーがトークンの大部分を所有している場合、トークンの再分配に基づいて操作に影響を与える可能性があります。 +- \*\*総供給量が十分であること。\*\*総供給量が少ないトークンは、簡単に操作される可能性があります。 +- \*\*トークンが複数の取引所に存在すること。\*\*すべてのトークンが1つの取引所にしかない場合、その取引所が侵害されると、トークンに依存するコントラクトも侵害される可能性があります。 +- \*\*多額の資金やフラッシュローンに伴うリスクをユーザーが理解していること。\*\*トークン残高に依存するコントラクトは、多額の資金を持つ攻撃者やフラッシュローンによる攻撃を慎重に考慮する必要があります。 +- **トークンがフラッシュミンティングを許可しないこと**。 フラッシュミンティングは残高と総供給量の大幅な変動につながる可能性があり、そのためトークンの運用において厳格かつ包括的なオーバーフローチェックが必要になります。 diff --git a/public/content/translations/ja/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md b/public/content/translations/ja/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md index 4cdf617692d..47a628e5dba 100644 --- a/public/content/translations/ja/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md +++ b/public/content/translations/ja/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md @@ -1,12 +1,8 @@ --- -title: SolidityスマートコントラクトによるERC-20トークンの転送と承認 -description: Solidity言語で書かれたトークンとやり取りするには、スマートコントラクトをどのように使用すればよいか +title: "SolidityスマートコントラクトによるERC-20トークンの転送と承認" +description: "Solidityを使用してERC-20トークンの転送と承認を処理するDEXスマートコントラクトを構築します。" author: "jdourlens" -tags: - - "スマートコントラクト" - - "トークン" - - "Solidity" - - "erc-20" +tags: ["smart contracts", "tokens", "solidity", "erc-20"] skill: intermediate lang: ja published: 2020-04-07 @@ -17,7 +13,7 @@ address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE" 前回のチュートリアルでは、イーサリアムブロックチェーン上の[Solidityで描かれたERC-20トークンの構造](/developers/tutorials/understand-the-erc-20-token-smart-contract/)について学びました。 この記事では、Solidity言語で書かれたトークンとやり取りするためのスマートコントラクトの使い方について説明します。 -このスマートコントラクトのために、新しくデプロイされた[ERC-20トークン](/developers/docs/standards/tokens/erc-20/)でイーサを取引できる、ダミーの分散型取引所を実際に作成します。 +このスマートコントラクトのために、ユーザーがイーサを新しくデプロイされた[ERC-20トークン](/developers/docs/standards/tokens/erc-20/)に交換できる、ダミーの分散型取引所を実際に作成します。 このチュートリアルでは、前のチュートリアルで書いたコードをベースとして使います。 この分散型取引所(DEX)では、コントラクトのインスタンスをコンストラクタでインスタンス化し、以下の操作を実行します。 @@ -60,11 +56,11 @@ contract ERC20Basic is IERC20 { constructor() { - balances[msg.sender] = totalSupply_; + balances[msg.sender] = totalSupply_; } function totalSupply() public override view returns (uint256) { - return totalSupply_; + return totalSupply_; } function balanceOf(address tokenOwner) public override view returns (uint256) { @@ -104,7 +100,7 @@ contract ERC20Basic is IERC20 { ``` -次の新しい分散型取引所(DEX)スマートコントラクトは 、ERC-20をデプロイし、供給されたすべてを取得します。 +次の新しい分散型取引所(DEX)スマートコントラクトは、ERC-20をデプロイし、供給されたすべてを取得します。 ```solidity contract DEX { @@ -136,7 +132,7 @@ contract DEX { ## buy関数 {#the-buy-function} -buy関数をコーディングしてみましょう。 まず、メッセージに含まれるイーサ(ETH)の量を確認し、コントラクトが十分なトークンを所有していることと、そのメッセージにいくつかのイーサ(ETH)が含まれていることを検証する必要があります。 コントラクトが十分なトークンを所有している場合、ユーザーにその分のトークンを送信し、 `Bought` イベントを発行します。 +buy関数をコーディングしてみましょう。 まず、メッセージに含まれるイーサ(ETH)の量を確認し、コントラクトが十分なトークンを所有していること、そしてメッセージにイーサ(ETH)が含まれていることを検証する必要があります。 コントラクトが十分なトークンを所有している場合、ユーザーにその分のトークンを送信し、`Bought`イベントを発行します。 require関数の呼び出しがエラーだった場合に、送信されたイーサ(ETH)は直接元に戻され、ユーザーに返されることに注意してください。 @@ -146,39 +142,39 @@ require関数の呼び出しがエラーだった場合に、送信されたイ function buy() payable public { uint256 amountTobuy = msg.value; uint256 dexBalance = token.balanceOf(address(this)); - require(amountTobuy > 0, "You need to send some ether"); - require(amountTobuy <= dexBalance, "Not enough tokens in the reserve"); + require(amountTobuy > 0, "イーサを送信する必要があります"); + require(amountTobuy <= dexBalance, "リザーブに十分なトークンがありません"); token.transfer(msg.sender, amountTobuy); emit Bought(amountTobuy); } ``` -購入が成功した場合、トランザクションには`Transfer`と`Bought`の2つのイベントが表示されます。 +購入が成功した場合、トランザクションにはトークンの`Transfer`と`Bought`の2つのイベントが表示されます。  ## sell関数 {#the-sell-function} -売却を行う関数は事前にapprove関数を呼び出し、ユーザーがその金額を承認することを要求します。 転送を承認するには、分散型取引所(DEX)によってインスタンス化されたERC20Basicトークンがユーザーによって呼び出される必要があります。 これは、まず分散型取引所(DEX)コントラクトの`token()`関数を呼び出し、分散型取引所(DEX)が`token`というERC20Basicコントラクトをデプロイしたアドレスを取得することで実現できます。 次に、セッション内にそのコントラクトのインスタンスを作成し、その`approve`関数を呼び出します。 次に、分散型取引所(DEX)の`sell`関数を呼び出すことで、トークンをイーサ(ETH)に交換できます。 例えば、インタラクティブ・ブラウニー(interactive brownie)セッションでは、次のようになります。 +売却を担当する関数では、まずユーザーが事前に`approve`関数を呼び出して、金額を承認しておく必要があります。 転送を承認するには、ユーザーがDEXによってインスタンス化されたERC20Basicトークンコントラクトを呼び出す必要があります。 これは、まずDEXコントラクトの`token()`関数を呼び出して、DEXが`token`というERC20Basicコントラクトをデプロイしたアドレスを取得することで実現できます。 次に、セッション内にそのコントラクトのインスタンスを作成し、その`approve`関数を呼び出します。 次に、DEXの`sell`関数を呼び出すことで、トークンをイーサ(ETH)に交換できます。 例えば、インタラクティブ・ブラウニー(interactive brownie)セッションでは、次のようになります。 ```python -#### Python in interactive brownie console... +#### インタラクティブ・ブラウニーコンソール内のPython... -# deploy the DEX +# DEXをデプロイする dex = DEX.deploy({'from':account1}) -# call the buy function to swap ether for token -# 1e18 is 1 ether denominated in wei +# buy関数を呼び出してイーサをトークンにスワップする +# 1e18はweiで表記した1イーサ dex.buy({'from': account2, 1e18}) -# get the deployment address for the ERC20 token -# that was deployed during DEX contract creation -# dex.token() returns the deployed address for token +# DEXコントラクト作成時にデプロイされた +# ERC20トークンのデプロイメントアドレスを取得する +# dex.token()はデプロイされたトークンのアドレスを返す token = ERC20Basic.at(dex.token()) -# call the token's approve function -# approve the dex address as spender -# and how many of your tokens it is allowed to spend +# トークンのapprove関数を呼び出す +# dexアドレスを使用者(spender)として承認し、 +# いくつのトークンを使用許可するかを指定する token.approve(dex.address, 3e18, {'from':account2}) ``` @@ -187,24 +183,24 @@ token.approve(dex.address, 3e18, {'from':account2}) ```solidity function sell(uint256 amount) public { - require(amount > 0, "You need to sell at least some tokens"); + require(amount > 0, "少なくともいくらかのトークンを売る必要があります"); uint256 allowance = token.allowance(msg.sender, address(this)); - require(allowance >= amount, "Check the token allowance"); + require(allowance >= amount, "トークンの許可量を確認してください"); token.transferFrom(msg.sender, address(this), amount); payable(msg.sender).transfer(amount); emit Sold(amount); } ``` -すべてがうまくいけば、トランザクションに2つのイベント(`Transfer` と `Sold`)が表示され、トークンの残高とイーサの残高が更新されるはずです。 +すべてがうまくいけば、トランザクションに2つのイベント (`Transfer`と`Sold`) が表示され、トークンの残高とイーサの残高が更新されるはずです。  -このチュートリアルでは、残高とERC-20トークンの割当量を確認する方法と、インターフェースを使用してERC20スマートコントラクトの`Transfer`と`TransferFrom`を呼び出す方法について説明しました。 +このチュートリアルでは、ERC-20トークンの残高と許可量を確認する方法と、インターフェースを使用してERC20スマートコントラクトの`Transfer`と`TransferFrom`を呼び出す方法を学びました。 -一度トランザクションが作成されると、コントラクト用に作成されている[待機してトランザクションについての詳細を取得する](https://ethereumdev.io/waiting-for-a-transaction-to-be-mined-on-ethereum-with-js/)ためのJavaScriptチュートリアルや、アプリケーションバイナリインターフェース(ABI)があれば、[トークン転送や他のイベントによって発行されるイベントをデコードするチュートリアル](https://ethereumdev.io/how-to-decode-event-logs-in-javascript-using-abi-decoder/)を参照することで情報を取得できます。 +トランザクションを実行した後には、コントラクトに対して行われた[トランザクションを待機し、詳細を取得する](https://ethereumdev.io/waiting-for-a-transaction-to-be-mined-on-ethereum-with-js/)ためのJavaScriptチュートリアルがあります。また、ABIをお持ちであれば、トークンの転送やその他のイベントによって生成された[イベントをデコードするチュートリアル](https://ethereumdev.io/how-to-decode-event-logs-in-javascript-using-abi-decoder/)も利用できます。 チュートリアルの完全なコードは、次のようになります。 @@ -242,11 +238,11 @@ contract ERC20Basic is IERC20 { constructor() { - balances[msg.sender] = totalSupply_; + balances[msg.sender] = totalSupply_; } function totalSupply() public override view returns (uint256) { - return totalSupply_; + return totalSupply_; } function balanceOf(address tokenOwner) public override view returns (uint256) { @@ -299,16 +295,16 @@ contract DEX { function buy() payable public { uint256 amountTobuy = msg.value; uint256 dexBalance = token.balanceOf(address(this)); - require(amountTobuy > 0, "You need to send some ether"); - require(amountTobuy <= dexBalance, "Not enough tokens in the reserve"); + require(amountTobuy > 0, "イーサを送信する必要があります"); + require(amountTobuy <= dexBalance, "リザーブに十分なトークンがありません"); token.transfer(msg.sender, amountTobuy); emit Bought(amountTobuy); } function sell(uint256 amount) public { - require(amount > 0, "You need to sell at least some tokens"); + require(amount > 0, "少なくともいくらかのトークンを売る必要があります"); uint256 allowance = token.allowance(msg.sender, address(this)); - require(allowance >= amount, "Check the token allowance"); + require(allowance >= amount, "トークンの許可量を確認してください"); token.transferFrom(msg.sender, address(this), amount); payable(msg.sender).transfer(amount); emit Sold(amount); diff --git a/public/content/translations/ja/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md b/public/content/translations/ja/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md index 80335862de8..9274203e908 100644 --- a/public/content/translations/ja/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md +++ b/public/content/translations/ja/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md @@ -1,12 +1,8 @@ --- -title: ERC-20トークンのスマートコントラクトを理解する -description: イーサリアムのテストネットワーク上で最初のスマートコントラクトをデプロイする手順 +title: "ERC-20トークンのスマートコントラクトを理解する" +description: "完全なSolidityスマートコントラクトの例と解説で、ERC-20トークン標準の実装方法を学びます。" author: "jdourlens" -tags: - - "スマートコントラクト" - - "トークン" - - "Solidity" - - "erc-20" +tags: ["smart contracts", "tokens", "solidity", "erc-20"] skill: beginner lang: ja published: 2020-04-05 @@ -15,11 +11,11 @@ sourceUrl: https://ethereumdev.io/understand-the-erc20-token-smart-contract/ address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE" --- -[ERC-20](/developers/docs/standards/tokens/erc-20/)は、イーサリアムで最も重要な[スマートコントラクト](/developers/docs/standards/)の1つとして知られており、イーサリアムブロックチェーン上のすべてのスマートコントラクトで代替可能なトークンを実装するために用いられる規格として開発されました。 +イーサリアムにおける最も重要な[スマートコントラクト標準](/developers/docs/standards/)の1つは[ERC-20](/developers/docs/standards/tokens/erc-20/)として知られており、これは、代替可能なトークン実装のためにイーサリアムブロックチェーン上のすべてのスマートコントラクトで使用される技術標準として登場しました。 -ERC-20では、すべての代替可能なイーサリアムトークンが順守すべき共通ルールを定義しています。 この規格によって、開発者はイーサリアムの大規模なシステム内で新しいトークンがどのように機能するかを正確に予測できます。 トークンが技術標準のルールに従う限り、すべてのプロジェクトにおいて、新しいトークンがリリースされるたびに最初から開発し直す必要がなくなるため、開発者の負担が軽減されます。 +ERC-20は、すべての代替可能なイーサリアムトークンが準拠すべき共通のルールリストを定義します。 その結果、このトークン標準により、あらゆる種類の開発者が、より大きなイーサリアムシステム内で新しいトークンがどのように機能するかを正確に予測できるようになります。 これにより開発者のタスクは簡素化され、容易になります。トークンがルールに従っている限り、新しいトークンがリリースされるたびに、それぞれの新しいプロジェクトをやり直す必要がないと分かった上で、作業を進めることができるからです。 -ERC-20で実装しなければならないインターフェイスを以下に提示します。 インターフェイスの詳細については、Solidityの[OOPプログラミング](https://ethereumdev.io/inheritance-in-solidity-contracts-are-classes/)についての記事をご覧ください。 +以下は、ERC-20が実装しなければならない関数をインターフェイスとして提示したものです。 インターフェイスが何であるかよくわからない場合は、[SolidityでのOOPプログラミング](https://ethereumdev.io/inheritance-in-solidity-contracts-are-classes/)に関する私たちの記事を確認してください。 ```solidity pragma solidity ^0.6.0; @@ -40,27 +36,27 @@ interface IERC20 { } ``` -ここでは、それぞれの関数の役割について説明しています。 その後、ERC-20トークンの簡単な実装をご紹介します。 +ここでは、すべての関数が何のためにあるのかを一行ずつ解説します。 この後、ERC-20トークンの簡単な実装を紹介します。 -## Getters {#getters} +## ゲッター {#getters} ```solidity function totalSupply() external view returns (uint256); ``` -存在するトークンの総量を返します。 この関数はgetter関数であり、コントラクトの状態を変更することはありません。 Solidityには浮動小数点が存在しないことに注意してください。 したがって、ほとんどのトークンは18桁で表記され、1トークンに対して10000000000000000となるように総供給量などの結果を返します。 ただし、すべてのトークンが18桁ではないため、トークンを扱うときには注意が必要です。 +存在するトークンの総量を返します。 この関数はゲッターであり、コントラクトの状態を変更しません。 Solidityには浮動小数点数がないことに注意してください。 したがって、ほとんどのトークンは18桁の小数を採用しており、1トークンに対して1000000000000000000のように総供給量やその他の結果を返します。 すべてのトークンが18桁の小数を持つわけではなく、これはトークンを扱う際に本当に注意する必要があることです。 ```solidity function balanceOf(address account) external view returns (uint256); ``` -アドレス(`account`)が所有するトークンの量を返します。 この関数はgetter関数であり、コントラクトの状態を変更することはありません。 +アドレス(`account`)が所有するトークンの量を返します。 この関数はゲッターであり、コントラクトの状態を変更しません。 ```solidity function allowance(address owner, address spender) external view returns (uint256); ``` -ERC-20は、あるアドレスが他のアドレスに権限を与え、そのアドレスからトークンを取り戻すことができます。 この関数は、`spender`が`owner`のために使用可能なトークンの残数を返します。 この関数はgetter関数であり、コントラクトの状態を変更することはありません。したがってデフォルトで0が返ってきます +ERC-20標準では、あるアドレスが別のアドレスに対し、そのアドレスからトークンを取得できる許可(allowance)を与えることができます。 このゲッターは、`spender`が`owner`に代わって使用できる、許可されたトークンの残量を返します。 この関数はゲッターであり、コントラクトの状態を変更しません。デフォルトでは0を返すべきです。 ## 関数 {#functions} @@ -68,19 +64,19 @@ ERC-20は、あるアドレスが他のアドレスに権限を与え、その function transfer(address recipient, uint256 amount) external returns (bool); ``` -関数を呼び出したアドレス(`msg.sender`)から受け取りアドレスに`amount`のトークンを送信します。 この関数は、後で定義する`Transfer`イベントを発行します。 トークンの送金が可能な場合、trueを返します。 +`amount`のトークンを、関数呼び出し元のアドレス(`msg.sender`)から受取人アドレスに移動します。 この関数は、後で定義される`Transfer`イベントを発行します。 送金が可能だった場合は、trueを返します。 ```solidity function approve(address spender, uint256 amount) external returns (bool); ``` -関数を呼び出したアドレス(`msg.sender`)の残高から`spender`が送金できる`allowance`を設定します。 この関数は、承認イベントを発行します。 この関数は、承認が成功したか否かを返します。 +`spender`が関数呼び出し元(`msg.sender`)の残高から送金できる`allowance`(許可額)を設定します。 この関数は`Approval`イベントを発行します。 この関数は、allowanceが正常に設定されたかどうかを返します。 ```solidity function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); ``` -`amount`のトークンを`sender`から`recipient`へ承認メカニズムを使って送金します。 関数を呼び出したアドレスから手数料が差し引かれます。 この関数は、`Transfer`イベントを発行します。 +allowanceの仕組みを使い、`amount`のトークンを`sender`から`recipient`に移動させます。 `amount`は、呼び出し元のallowanceから差し引かれます。 この関数は`Transfer`イベントを発行します。 ## イベント {#events} @@ -88,19 +84,19 @@ function transferFrom(address sender, address recipient, uint256 amount) externa event Transfer(address indexed from, address indexed to, uint256 value); ``` -トークンの量(値)が`from`アドレスから`to`アドレスに送信されると、このイベントが発行されます。 +このイベントは、トークンの量(`value`)が`from`アドレスから`to`アドレスに送金されたときに発行されます。 -新しいトークンをミントする場合、送金イベントは通常`from`0x00...0000アドレスであるのに対し、トークンをバーンする場合は`to`0x00...0000となります。 +新しいトークンをミントする場合、送金は通常`from`が0x00..0000アドレスとなり、トークンをバーンする場合は`to`が0x00..0000となります。 ```solidity event Approval(address indexed owner, address indexed spender, uint256 value); ``` -このイベントは、トークンの量(`value`)が`owner`によって、`spender`に使用することが承認されたときに発行されるものです。 +このイベントは、トークンの量(`value`)が`owner`によって`spender`に使用されることが承認されたときに発行されます。 ## ERC-20トークンの基本的な実装 {#a-basic-implementation-of-erc-20-tokens} -ERC-20トークンのベースとなるシンプルなコードを以下にご紹介します。 +ERC-20トークンのベースとなる最もシンプルなコードを以下に示します。 ```solidity pragma solidity ^0.8.0; @@ -136,11 +132,11 @@ contract ERC20Basic is IERC20 { constructor() { - balances[msg.sender] = totalSupply_; + balances[msg.sender] = totalSupply_; } function totalSupply() public override view returns (uint256) { - return totalSupply_; + return totalSupply_; } function balanceOf(address tokenOwner) public override view returns (uint256) { @@ -178,4 +174,4 @@ contract ERC20Basic is IERC20 { } ``` -ERC-20トークン規格のもう1つのすばらしい実装として、[OpenZeppelin ERC-20実装](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20)があります。 +ERC-20トークン標準のもう一つの優れた実装として、[OpenZeppelinのERC-20実装](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20)があります。 diff --git a/public/content/translations/ja/developers/tutorials/uniswap-v2-annotated-code/index.md b/public/content/translations/ja/developers/tutorials/uniswap-v2-annotated-code/index.md index a86e21bd040..eb9ec0b5ecf 100644 --- a/public/content/translations/ja/developers/tutorials/uniswap-v2-annotated-code/index.md +++ b/public/content/translations/ja/developers/tutorials/uniswap-v2-annotated-code/index.md @@ -1,9 +1,8 @@ --- -title: "Uniswap-v2コントラクトの手順" -description: Uniswap-v2コントラクトの仕組み、 コントラクトの書き方について +title: "Uniswap-v2コントラクトの詳細解説" +description: "Uniswap-v2コントラクトはどのように機能するのか? なぜそのように記述されているのか?" author: Ori Pomerantz -tags: - - "Solidity" +tags: ["solidity"] skill: intermediate published: 2021-05-01 lang: ja @@ -11,104 +10,105 @@ lang: ja ## はじめに {#introduction} -[Uniswap v2](https://uniswap.org/whitepaper.pdf)では、任意の2つのERC-20トークン同士の取引が可能になります。 本記事では、このプロトコルを実装したコントラクトのソースコードをチェックして、このように書かれている理由を理解していきます。 +[Uniswap v2](https://app.uniswap.org/whitepaper.pdf)は、任意の2つのERC-20トークン間で取引市場を作成できます。 この記事では、このプロトコルを実装するコントラクトのソースコードをレビューし、なぜこのように記述されているのかを見ていきます。 -### Uniswapの役割 {#what-does-uniswap-do} +### Uniswapの機能 {#what-does-uniswap-do} -基本的には、流動性プロバイダーとトレーダーの2種類のユーザーが存在します。 +基本的に、流動性プロバイダーとトレーダーの2種類のユーザーが存在します。 -_liquidity providers_(流動性プロバイダー)は、交換可能な2つのトークン(ここでは**Token0**と**Token1**と呼びます)をプールに提供します。 その見返りとして、_liquidity token_(流動性トークン)と呼ばれるプールの一部所有権を表す第3のトークンを受け取ります。 +_流動性プロバイダー_は、交換可能な2つのトークン(ここでは**Token0**と**Token1**と呼びます)をプールに提供します。 その見返りとして、_流動性トークン_と呼ばれるプールの一部所有権を表す第3のトークンを受け取ります。 -_Traders_(トレーダー)は、あるトークンをプールに送り、流動性プロバイダーが提供するプールから他のトークン(例えば、**Token0**を送って**Token1**を受け取る)を受け取ります。 交換レートは、プールが持つ**Token0**と**Token1**の相対的な数で決定されます。 加えて、流動性プールの報酬としてプールに数パーセントのフィーを取られます。 +_トレーダー_は、ある種類のトークンをプールに送り、流動性プロバイダーが提供するプールから他のトークン(例えば、**Token0**を送って**Token1**を受け取る)を受け取ります。 交換レートは、プールが保有する**Token0**と**Token1**の相対的な数で決定されます。 さらに、プールは流動性プールへの報酬として少額のパーセンテージを受け取ります。 -流動性プロバイダーが元のトークンを取り戻したい場合は、プールトークンをバーンして、報酬を含めた元のトークンを受け取ることができます。 +流動性プロバイダーが資産を取り戻したい場合は、プールトークンをバーンして、報酬の分け前を含めた元のトークンを受け取ることができます。 -詳しい説明は[こちら](https://docs.uniswap.org/contracts/v2/concepts/core-concepts/swaps/)をご覧ください。 +[詳細な説明はこちら](https://docs.uniswap.org/contracts/v2/concepts/core-concepts/swaps/)。 -### なぜv2? v3じゃないの? {#why-v2} +### なぜv2なのか? なぜv3ではないのか? {#why-v2} -[Uniswap v3](https://uniswap.org/whitepaper-v3.pdf)はv2を非常に複雑化したアップグレード版です。 まずv2を学んでからv3に進む方が簡単です。 +[Uniswap v3](https://app.uniswap.org/whitepaper-v3.pdf)は、v2よりもはるかに複雑なアップグレードです。 まずv2を学んでからv3に進む方が簡単です。 ### コアコントラクト vs ペリフェリーコントラクト {#contract-types} -Uniswap v2は、コアコントラクトとペリフェリーコントラクトの2つのコンポーネントに分かれています。 コアコントラクトはアセットを_保有する_ため安全性の保証が重要となりますが、この分割によって監査を簡略化することができます。 ペリフェリーコントラクトはトレーダーが必要とするすべての機能を提供しています。 +Uniswap v2は、コアとペリフェリーの2つのコンポーネントに分かれています。 この分割により、資産を保有し、したがって安全でなければならないコアコントラクトを、よりシンプルで監査しやすくすることができます。 トレーダーが必要とするすべての追加機能は、ペリフェリーコントラクトによって提供されます。 -## データおよび制御フロー {#flows} +## データと制御のフロー {#flows} -Uniswapの3大アクションを実行したときに発生するデータフローと制御フローは以下のとおりです。 +これは、Uniswapの3つの主要なアクションを実行するときに発生するデータと制御のフローです。 -1. 異なるトークン間でスワップを実行する -2. 市場に流動性を与え、ERC-20流動性トークンのペア取引で報酬を得る -3. ERC-20流動性トークンをバーンし、ペア取引によってトレーダーが取引できるERC-20トークンを取り戻す +1. 異なるトークン間のスワップ +2. 市場に流動性を追加し、ペア取引所のERC-20流動性トークンで報酬を得る +3. ERC-20流動性トークンをバーンし、ペア取引所でトレーダーが交換できるERC-20トークンを取り戻す ### スワップ {#swap-flow} -トレーダーが使用する最も一般的なフローです。 +これはトレーダーが使用する最も一般的なフローです: #### 呼び出し元 {#caller} -1. スワップされた量のアローワンスをペリフェリーアカウントへ提供します。 -2. ペリフェリーコントラクトには多数のスワップ関数がありますが、そのうち1つを呼び出します(ETHが関係しているかどうか、入金するトークンの量や取り戻すトークンの量をトレーダーが指定するかどうかなどによって、呼び出す関数は異なります)。 どのスワップ関数も`path`、つまり経由する取引所の配列を受け取ります。 +1. スワップされる量のアローワンス(許容量)をペリフェリーアカウントに提供します。 +2. ペリフェリーコントラクトの多数あるスワップ関数のうち1つを呼び出します(どの関数を呼び出すかは、ETHが関与しているか、トレーダーが入金するトークンの量や受け取るトークンの量を指定するかなどによって決まります)。 + すべてのスワップ関数は、経由する取引所の配列である`path`を受け入れます。 -#### ペリフェリーコントラクト内の処理 (UniswapV2Router02.sol) {#in-the-periphery-contract-uniswapv2router02-sol} +#### ペリフェリーコントラクト(UniswapV2Router02.sol)にて {#in-the-periphery-contract-uniswapv2router02-sol} -3. パスに沿って、各取引所で取引する量を特定します。 -4. パスを繰り返し処理します。 経路にある各取引所に入力トークンを送信し、取引所の`スワップ`関数を呼び出します。 通常、トークンの送信先アドレスはパス上にある次のペア取引所です。 最後の取引は、トレーダーが提供したアドレスとなります。 +3. パスに沿って各取引所で取引する必要がある量を特定します。 +4. パスを反復処理します。 経路上のすべての取引所について、入力トークンを送信し、取引所の`swap`関数を呼び出します。 + ほとんどの場合、トークンの宛先アドレスはパス上の次のペア取引所になります。 最後の取引所では、トレーダーが提供したアドレスになります。 -#### コアコントラクト内の処理(UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2} +#### コアコントラクト(UniswapV2Pair.sol)にて {#in-the-core-contract-uniswapv2pairsol-2}5. コアコントラクトで不正が行われておらず、スワップ後も十分な流動性を維持できることを検証します。 -5. コアコントラクトで不正がされていないこと、スワップ後も十分な流動性を維持できることを検証します。 -6. 既存のリザーブ量と追加のトークン数を確認します。 追加のトークン量は、交換用に受け取った入力トークンの数です。 -7. 出力トークンを送信先に送ります。 -8. `_update`を呼び出し、リザーブ量をアップデートします。 +6. 既知のリザーブに加えて、どれだけの追加トークンがあるかを確認します。 その量が、交換のために受け取った入力トークンの数です。 +7. 出力トークンを宛先に送信します。 +8. `_update`を呼び出してリザーブ量を更新します。 #### ペリフェリーコントラクト(UniswapV2Router02.sol)に戻る {#back-in-the-periphery-contract-uniswapv2router02-sol} -9. 必要なクリーンアップを行います(例えば、WETHトークンをバーンしてETHへ戻し、トレーダーに送るなど)。 +9. 必要なクリーンアップを実行します(例: WETHトークンをバーンしてETHに戻し、トレーダーに送信する)。 ### 流動性の追加 {#add-liquidity-flow} #### 呼び出し元 {#caller-2} -1. 流動性プールに追加される量のアローワンスをペリフェリーアカウントに提供します。 +1. 流動性プールに追加される量のアローワンス(許容量)をペリフェリーアカウントに提供します。 2. ペリフェリーコントラクトの`addLiquidity`関数の1つを呼び出します。 -#### ペリフェリーコントラクト内の処理(UniswapV2Router02.sol) {#in-the-periphery-contract-uniswapv2router02sol-2} +#### ペリフェリーコントラクト(UniswapV2Router02.sol)にて {#in-the-periphery-contract-uniswapv2router02sol-2} 3. 必要に応じて新しいペア取引所を作成します。 -4. 既存のペア取引所がある場合は、追加するトークンの量を計算します。 両方のトークンは同じ値であることが想定されるため、新規トークンと既存トークンの比率は同じになるはずです。 -5. 受け取り可能なトークンの量かどうか確認します(実行者は流動性の追加を希望しない最低量を指定することができます) 。 +4. 既存のペア取引所がある場合は、追加するトークンの量を計算します。 これは両方のトークンで同じ値であることが想定されているため、新規トークンと既存トークンの比率は同じになるはずです。 +5. 受け取り可能なトークンの量かどうか確認します(実行者は流動性の追加を希望しない最低量を指定することができます)。 6. コアコントラクトを呼び出します。 -#### コアコントラクト内の処理(UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2} +#### コアコントラクト(UniswapV2Pair.sol)にて {#in-the-core-contract-uniswapv2pairsol-2} 7. 流動性トークンをミントして、呼び出し元に送信します。 -8. `_update`を呼び出し、リザーブ量をアップデートします。 +8. `_update`を呼び出してリザーブ量を更新します。 ### 流動性の削除 {#remove-liquidity-flow} #### 呼び出し元 {#caller-3} -1. ペリフェリーアカウントに、基礎トークンと引き換えにバーンされた流動性トークンのアローワンスを提供します。 +1. ペリフェリーアカウントに、基礎となるトークンと引き換えにバーンされる流動性トークンのアローワンス(許容量)を提供します。 2. ペリフェリーコントラクトの`removeLiquidity`関数の内の1つを呼び出します。 -#### ペリフェリーコントラクト内の処理(UniswapV2Router02.sol) {#in-the-periphery-contract-uniswapv2router02sol-3} +#### ペリフェリーコントラクト(UniswapV2Router02.sol)にて {#in-the-periphery-contract-uniswapv2router02sol-3} 3. ペア取引所に流動性トークンを送ります。 -#### コアコントラクト(UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-3} +#### コアコントラクト(UniswapV2Pair.sol)にて {#in-the-core-contract-uniswapv2pairsol-3} -4. バーンされたトークンの量に応じて、基礎トークンを送信先アドレスに送ります。 例えば、プールにAトークンが1000個、Bトークンが500個、流動性トークンが90個あるとします。流動性トークン9個を受け取ってバーンすると、流動性トークンの10%をバーンすることになり、ユーザーに100個のAトークンと50個のBトークンが返されることになります。 +4. バーンされたトークンの量に応じて、基礎となるトークンを宛先アドレスに送ります。 例えば、プールにAトークンが1000個、Bトークンが500個、流動性トークンが90個あるとします。流動性トークン9個を受け取ってバーンすると、流動性トークンの10%をバーンすることになり、ユーザーに100個のAトークンと50個のBトークンが返されることになります。 5. 流動性トークンをバーンします。 -6. `_update`を呼び出し、リザーブ量をアップデートします。 +6. `_update`を呼び出してリザーブ量を更新します。 ## コアコントラクト {#core-contracts} -流動性を保持する安全なコントラクトです。 +これらは流動性を保持する安全なコントラクトです。 ### UniswapV2Pair.sol {#UniswapV2Pair} -[このコントラクト](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Pair.sol)は、トークンを交換する実際のプールを実装しています。 これはUniswapの中核機能です。 +[このコントラクト](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Pair.sol)は、トークンを交換する実際のプールを実装します。 これはUniswapの中核機能です。 ```solidity pragma solidity =0.5.16; @@ -122,7 +122,7 @@ import './interfaces/IUniswapV2Factory.sol'; import './interfaces/IUniswapV2Callee.sol'; ``` -コントラクトは、これら(`IUniswapV2Pair`や`UniswapV2ERC20`)を実装していたり、これらを実装したコントラクトを呼び出すため、上記すべてのインターフェイスを認識する必要があります。 +これらはすべて、コントラクトが認識する必要のあるインターフェースです。コントラクトがそれらを実装しているか(`IUniswapV2Pair`と`UniswapV2ERC20`)、あるいはそれらを実装したコントラクトを呼び出しているためです。 ```solidity contract UniswapV2Pair is IUniswapV2Pair, UniswapV2ERC20 { @@ -134,15 +134,16 @@ contract UniswapV2Pair is IUniswapV2Pair, UniswapV2ERC20 { using SafeMath for uint; ``` -この[SafeMathライブラリ](https://docs.openzeppelin.com/contracts/2.x/api/math)は、オーバーフローとアンダーフローを回避するために使用されます。 このライブラリがないと、`-1`であるべき値が`2^256-1`になってしまうことがあるため重要な役割を担っています。 +[SafeMathライブラリ](https://docs.openzeppelin.com/contracts/2.x/api/math)は、オーバーフローやアンダーフローを回避するために使用されます。 このライブラリがないと、-1であるべき値が2^256-1になってしまうことがあるため、これは重要です。 ```solidity using UQ112x112 for uint224; ``` -通常、プールコントラクトの計算では小数を使いますが、 EVMで小数はサポートされていません。 そこで、Uniswapが考えた解決策は、224ビット値を使用することです。整数部分に112 ビット、小数部分に112ビットを使います つまり、`1.0`は`2^112`、`1.5`は`2^112 + 2^111`のように表します。 +プールコントラクトの計算の多くは小数を必要とします。 しかし、小数はEVMでサポートされていません。 +Uniswapが考えた解決策は、224ビット値を使用することです。整数部分に112ビット、小数部分に112ビットを使います。 つまり、`1.0`は`2^112`、`1.5`は`2^112 + 2^111`のように表します。 -このライブラリの詳細は、[後述するドキュメント](#FixedPoint)に掲載されています。 +このライブラリの詳細については、[このドキュメントの後半](#FixedPoint)で説明します。 #### 変数 {#pair-vars} @@ -150,7 +151,7 @@ contract UniswapV2Pair is IUniswapV2Pair, UniswapV2ERC20 { uint public constant MINIMUM_LIQUIDITY = 10**3; ``` -ゼロ除算のケースを回避するため、流動性トークンには常に最小数が存在します(ただし、ゼロアカウントが所有しています。) その数は**MINIMUM_LIQUIDITY**であり、1000です。 +ゼロ除算のケースを回避するため、流動性トークンには常に最小数が存在します(ただし、ゼロアカウントが所有しています)。 その数は**MINIMUM_LIQUIDITY**であり、1000です。 ```solidity bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)'))); @@ -169,14 +170,14 @@ contract UniswapV2Pair is IUniswapV2Pair, UniswapV2ERC20 { address public token1; ``` -このプールで交換可能な2種類のERC-20トークンのコントラクトアドレスがあります。 +これらは、このプールで交換可能な2種類のERC-20トークンのコントラクトアドレスです。 ```solidity uint112 private reserve0; // uses single storage slot, accessible via getReserves uint112 private reserve1; // uses single storage slot, accessible via getReserves ``` -プールが保有する各種トークンのリザーブです。 2つが同じ値であると仮定すると、各token0はreserve1/reserve0 token1に相当します。 +プールが保有する各種トークンのリザーブです。 2つが同じ値であると仮定すると、各token0はreserve1/reserve0個のtoken1に相当します。 ```solidity uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves @@ -184,33 +185,33 @@ contract UniswapV2Pair is IUniswapV2Pair, UniswapV2ERC20 { 交換が行われた最後のブロックのタイムスタンプで、時間の経過とともに交換レートを追跡する際に使用されます。 -イーサリアムのコントラクトで最も高額なガス代の1つはストレージで、コントラクトコールから次のコールまで持続します。 各ストレージセルは256ビットとなっているため、 3つの変数`reserve0`、`reserve1`、`blockTimestampLast`すべて(112+112+32=256)を1つのストレージ値に含めるように割り当てます。 +イーサリアムのコントラクトで最もガス代が高くなるものの1つはストレージで、これはコントラクトの呼び出しから次の呼び出しまで持続します。 各ストレージセルは256ビット長です。 そのため、3つの変数`reserve0`、`reserve1`、`blockTimestampLast`は、1つのストレージ値に3つすべてを含めることができるように割り当てられています(112+112+32=256)。 ```solidity uint public price0CumulativeLast; uint public price1CumulativeLast; ``` -これらの変数は、各トークンの累積コストを(お互いの価値で)保有し、 一定期間の平均交換レートを算出する際に使用できます。 +これらの変数は、各トークンの累積コストを(お互いの価値で)保有します。 これらは一定期間の平均交換レートを算出する際に使用できます。 ```solidity uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event ``` -token0とtoken1の交換レートは、取引時の両リザーブの倍数を一定に維持するようペア取引所が決定します。 `kLast`がその値です。 流動性プロバイダーがトークンを入出金するとこのレートは変化し、マーケット手数料0.3%によって若干増えます。 +ペア取引所がtoken0とtoken1の間の交換レートを決定する方法は、取引中に2つのリザーブの積を一定に保つことです。 `kLast`がその値です。 流動性プロバイダーがトークンを入出金するとこの値は変化し、0.3%の市場手数料によって若干増加します。 -下記にシンプルな例をご紹介します。 ただし、簡略化のため表は小数点以下3桁までとし、0.3%のマーケット手数料も考慮していないので正確な数字ではありません。 +以下に簡単な例をご紹介します。 ただし、簡潔化のため、表は小数点以下3桁までとし、0.3%の取引手数料は無視しているため、数値は正確ではありません。 -| イベント | reserve0 | reserve1 | reserve0 \* reserve1 | 平均交換レート(token1/token0) | -| ------------------------------------ | ---------:| ---------:| ----------------------:| ---------------------- | -| 初期設定 | 1,000.000 | 1,000.000 | 1,000,000 | | -| トレーダーAが50のtoken0を47.619のtoken1とスワップ | 1,050.000 | 952.381 | 1,000,000 | 0.952 | -| トレーダーBが10のtoken0を8.984のtoken1と スワップ | 1,060.000 | 943.396 | 1,000,000 | 0.898 | -| トレーダーCが40のtoken0を34.305のtoken1とスワップ | 1,100.000 | 909.090 | 1,000,000 | 0.858 | -| トレーダーDが100のtoken1を109.01のtoken0とスワップ | 990.990 | 1,009.090 | 1,000,000 | 0.917 | -| トレーダーEが10のtoken0を10.079のtoken1とスワップ | 1,000.990 | 999.010 | 1,000,000 | 1.008 | +| イベント | reserve0 | reserve1 | reserve0 \* reserve1 | 平均交換レート(token1 / token0) | +| ---------------------------------------------------- | ------------------------: | ------------------------: | -------------------: | ------------------------------------------- | +| 初期設定 | 1,000.000 | 1,000.000 | 1,000,000 | | +| トレーダーAが50 token0を47.619 token1とスワップ | 1,050.000 | 952.381 | 1,000,000 | 0.952 | +| トレーダーBが10 token0を8.984 token1とスワップ | 1,060.000 | 943.396 | 1,000,000 | 0.898 | +| トレーダーCが40 token0を34.305 token1とスワップ | 1,100.000 | 909.090 | 1,000,000 | 0.858 | +| トレーダーDが100 token1を109.01 token0とスワップ | 990.990 | 1,009.090 | 1,000,000 | 0.917 | +| トレーダーEが10 token0を10.079 token1とスワップ | 1,000.990 | 999.010 | 1,000,000 | 1.008 | -トレーダーが提供するtoken0の量が増えるほど、需要と供給によりtoken1の相対的価値も上がり、逆の場合も同じことが言えます。 +トレーダーが提供するtoken0の量が増えるほど、需要と供給によりtoken1の相対的価値も上がり、その逆もまた同様です。 #### ロック {#pair-lock} @@ -218,35 +219,36 @@ token0とtoken1の交換レートは、取引時の両リザーブの倍数を uint private unlocked = 1; ``` -[再入可能の悪用](https://medium.com/coinmonks/ethernaut-lvl-10-re-entrancy-walkthrough-how-to-abuse-execution-ordering-and-reproduce-the-dao-7ec88b912c14)によるセキュリティ脆弱性の一種があります。 Uniswapは、任意のERC-20トークンを転送することになっているため、Uniswapマーケットを悪用しようとするERC-20コントラクトを呼び出す可能性があります。 コントラクトの一部に`unlocked`変数を使うことで、(同じトランザクション内で)実行中に関数が呼び出されるのを防ぐことができます。 +[リエントランシー攻撃](https://medium.com/coinmonks/ethernaut-lvl-10-re-entrancy-walkthrough-how-to-abuse-execution-ordering-and-reproduce-the-dao-7ec88b912c14)に基づくセキュリティ脆弱性の一種があります。 Uniswapは任意のERC-20トークンを転送する必要があるため、それらを呼び出すUniswap市場を悪用しようとするERC-20コントラクトを呼び出す可能性があります。 +コントラクトの一部に`unlocked`変数を含めることで、(同じトランザクション内で)実行中に関数が呼び出されるのを防ぐことができます。 ```solidity modifier lock() { ``` -この関数は[modifier](https://docs.soliditylang.org/en/v0.8.3/contracts.html#function-modifiers)で、通常の関数をラップして何らかの方法で挙動を変更する関数です。 +この関数は[修飾子(modifier)](https://docs.soliditylang.org/en/v0.8.3/contracts.html#function-modifiers)であり、通常の関数をラップしてその動作を何らかの形で変更する関数です。 ```solidity require(unlocked == 1, 'UniswapV2: LOCKED'); unlocked = 0; ``` -`unlocked`が1の場合は0に設定します。 すでに0の場合は呼び出しを元に戻して、失敗させます。 +`unlocked`が1の場合は0に設定します。 すでに0の場合は呼び出しを元に戻し、失敗させます。 ```solidity _; ``` -modifierの`_;`は、(すべてのパラメータを含む)元の関数呼び出しです。 これは、関数が呼び出されたときに`unlocked`が1であり、実行中に`unlocked`の値が0になった場合のみ、関数呼び出しが発生することを意味します。 +修飾子において、`_;`は(すべてのパラメータを含む)元の関数呼び出しです。 これは、関数が呼び出されたときに`unlocked`が1であり、実行中に`unlocked`の値が0になった場合のみ、関数呼び出しが発生することを意味します。 ```solidity unlocked = 1; } ``` -main関数に戻った後、ロックを解除します。 +メイン関数が戻った後、ロックを解除します。 -#### その他の 関数 {#pair-misc} +#### その他 の関数 {#pair-misc} ```solidity function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) { @@ -256,28 +258,28 @@ main関数に戻った後、ロックを解除します。 } ``` -この関数が呼び出されると、取引所の現在の状態を返します。 Solidityの関数は、[複数の値を返せることに](https://docs.soliditylang.org/en/v0.8.3/contracts.html#returning-multiple-values)注意してください。 +この関数は、呼び出し元に取引所の現在の状態を提供します。 Solidityの関数は[複数の値を返す](https://docs.soliditylang.org/en/v0.8.3/contracts.html#returning-multiple-values)ことができることに注意してください。 ```solidity function _safeTransfer(address token, address to, uint value) private { (bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value)); ``` -この内部関数は、ERC20トークン量を取引所から第三者に転送します。 `SELECTOR`は、呼び出している関数が`transfer(address,uint)`(上記の定義を参照)であることを指定しています。 +この内部関数は、ある量のERC20トークンを取引所から第三者に転送します。 `SELECTOR`は、呼び出している関数が`transfer(address,uint)`(上記の定義を参照)であることを指定しています。 -トークン関数のインターフェイスのインポートを回避するため、いずれかの[ABI関数](https://docs.soliditylang.org/en/v0.8.3/units-and-global-variables.html#abi-encoding-and-decoding-functions)を使い、「手動」で呼び出しを作成します。 +トークン関数のインターフェースをインポートする必要がないように、[ABI関数](https://docs.soliditylang.org/en/v0.8.3/units-and-global-variables.html#abi-encoding-and-decoding-functions)の1つを使用して「手動で」呼び出しを作成します。 ```solidity require(success && (data.length == 0 || abi.decode(data, (bool))), 'UniswapV2: TRANSFER_FAILED'); } ``` -ERC-20転送コールが失敗を報告する例を下記に2つご紹介します。 +ERC-20転送コールが失敗を報告するには、2つの方法があります。 -1. 元に戻す。 外部コントラクトへのコールを元に戻すと、ブール値は`false`を返します。 -2. 正常に終了したが、失敗を報告する。 この場合、戻り値のバッファの長さがゼロ以外で、ブール値としてデコードすると`false`になります。 +1. リバート。 外部コントラクトへの呼び出しがリバートされると、ブール値の戻り値は`false`になります。 +2. 正常に終了するが、失敗を報告する。 その場合、戻り値バッファの長さはゼロ以外になり、ブール値としてデコードすると`false`になります。 -いずれかの状態が発生した場合は、元に戻します。 +これらの条件のいずれかが発生した場合は、リバートします。 #### イベント {#pair-events} @@ -286,7 +288,7 @@ ERC-20転送コールが失敗を報告する例を下記に2つご紹介しま event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); ``` -この2つのイベントは、流動性プロバイダーが流動性を入金 (`Mint`)または、引き出した(`Burn`)場合に発行されます。 いずれの場合も、預け入れまたは引き出されたtoken0とtoken1の量と、呼び出したアカウントのアイデンティティ(`sender`) は、イベントに含まれます。 引き出しの場合、イベントにはトークンを受け取るターゲット(`to`)も含みますが、送信者と同じとは限りません。 +これら2つのイベントは、流動性プロバイダーが流動性を入金(`Mint`)または引き出した(`Burn`)場合に発行されます。 いずれの場合も、預け入れまたは引き出されたtoken0とtoken1の量と、呼び出したアカウントのアイデンティティ(`sender`)は、イベントに含まれます。 引き出しの場合、イベントにはトークンを受け取るターゲット(`to`)も含まれますが、これは送信者と同じとは限りません。 ```solidity event Swap( @@ -299,17 +301,18 @@ ERC-20転送コールが失敗を報告する例を下記に2つご紹介しま ); ``` -このイベントは、トレーダーがあるトークンを他のトレーダーとスワップしたときに発行されます。 ここでも、送信者と送信先が同じとは限りません。 各トークンは、取引所に送信されるか、取引所から受信します。 +このイベントは、トレーダーがあるトークンを別のトークンとスワップしたときに発行されます。 ここでも、送信者と宛先が同じとは限りません。 +各トークンは、取引所に送信されるか、取引所から受信されます。 ```solidity event Sync(uint112 reserve0, uint112 reserve1); ``` -最後に、`Sync`は、トークンが追加または引き出されるたびに発行され、その理由に関係なく、最新のリザーブ情報(交換レート)を提供します。 +最後に、`Sync`は、理由に関係なくトークンが追加または引き出されるたびに発行され、最新のリザーブ情報(したがって交換レート)を提供します。 -#### setup関数 {#pair-setup} +#### セットアップ関数 {#pair-setup} -これらの関数は、新しいペア取引所がセットアップされたときに1度だけ呼び出されます。 +これらの関数は、新しいペア取引所がセットアップされたときに1度だけ呼び出されることになっています。 ```solidity constructor() public { @@ -317,7 +320,7 @@ ERC-20転送コールが失敗を報告する例を下記に2つご紹介しま } ``` -コンストラクタは、ペアを作成したファクトリのアドレスを確実に追跡できるようにします。 この情報は、`initialize`と(ファクトリが存在する場合は)ファクトリフィーに必要となります。 +コンストラクタは、ペアを作成したファクトリのアドレスを確実に追跡できるようにします。 この情報は、`initialize`と(存在する場合)ファクトリー手数料に必要です。 ```solidity // called once by the factory at time of deployment @@ -330,7 +333,7 @@ ERC-20転送コールが失敗を報告する例を下記に2つご紹介しま この関数では、ファクトリー(のみ)が、このペアが交換する2つのERC-20トークンを指定できます。 -#### 内部のupdate関数 {#pair-update-internal} +#### 内部更新関数 {#pair-update-internal} ##### \_update @@ -345,7 +348,7 @@ ERC-20転送コールが失敗を報告する例を下記に2つご紹介しま require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW'); ``` -balance0またはbalance1(uint256)が、uint112(-1) (=2^112-1)よりも大きい場合、(uint112に変換された場合、オーバーフローで0に戻ってしまうため)オーバーフローを防止するために\_updateの続行が拒否されます。 通常のトークンは10^18単位に分割できるため、各取引所で各トークンが約5.1*10^15に制限されます。 今のところ、問題は発生していません。 +balance0またはbalance1(uint256)のいずれかがuint112(-1) (=2^112-1)よりも大きい場合(つまり、uint112に変換されるとオーバーフローして0に戻る場合)、オーバーフローを防ぐために\_updateの続行を拒否します。 10^18単位に分割できる通常のトークンでは、これは各取引所が各トークン約5.1\*10^15に制限されることを意味します。 これまでのところ、問題は発生していません。 ```solidity uint32 blockTimestamp = uint32(block.timestamp % 2**32); @@ -353,7 +356,7 @@ balance0またはbalance1(uint256)が、uint112(-1) (=2^112-1)よりも大きい if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) { ``` -経過時間がゼロとなっていない場合は、このブロックで最初の交換トランザクションとなります。 その場合、コストアキュムレータをアップデートする必要があります。 +経過時間がゼロでない場合は、このブロックで最初の交換トランザクションであることを意味します。 その場合、コストアキュムレータを更新する必要があります。 ```solidity // * never overflows, and + overflow is desired @@ -362,18 +365,18 @@ balance0またはbalance1(uint256)が、uint112(-1) (=2^112-1)よりも大きい } ``` -各コストアキュムレータは、最新のコスト(他のトークンのリザーブまたはこのトークンのリザーブ)に経過時間(秒)を掛けてアップデートされます。 平均価格を求めるには、2つの時点の累積価格を読み、その時間差で割ります。 例えば、次の一連のイベントを想定してください。 +各コストアキュムレータは、最新のコスト(他のトークンのリザーブ/このトークンのリザーブ)に経過時間(秒)を掛けて更新されます。 平均価格を求めるには、2つの時点の累積価格を読み、その時間差で割ります。 例えば、次の一連のイベントを想定してください。 -| イベント | reserve0 | reserve1 | タイムスタンプ | 限界交換率(reserve1/reserve0) | price0CumulativeLast | -| ------------------------------------ | ---------:| ---------:| ------- | ------------------------:| ----------------------------:| -| 初期設定 | 1,000.000 | 1,000.000 | 5,000 | 1.000 | 0 | -| トレーダーAがtoken0を50入金し、token1を47.619戻す | 1,050.000 | 952.381 | 5,020 | 0.907 | 20 | -| トレーダーBがtoken0を10入金し、token1を8.984戻す | 1,060.000 | 943.396 | 5,030 | 0.890 | 20+10\*0.907 = 29.07 | -| トレーダーCがtoken0を40入金し、token1を34.305戻す | 1,100.000 | 909.090 | 5,100 | 0.826 | 29.07+70\*0.890 = 91.37 | -| トレーダーDがtoken1を100入金し、token0を109.01戻す | 990.990 | 1,009.090 | 5,110 | 1.018 | 91.37+10\*0.826 = 99.63 | -| トレーダーEがtoken0を10入金し、token1を10.079戻す | 1,000.990 | 999.010 | 5,150 | 0.998 | 99.63+40\*1.1018 = 143.702 | +| イベント | reserve0 | reserve1 | タイムスタンプ | 限界交換率(reserve1 / reserve0) | price0CumulativeLast | +| ------------------------------------------------------ | ------------------------: | ------------------------: | ------- | --------------------------------------------: | -------------------------------------------------------------------------: | +| 初期設定 | 1,000.000 | 1,000.000 | 5,000 | 1.000 | 0 | +| トレーダーAがtoken0を50入金し、token1を47.619受け取る | 1,050.000 | 952.381 | 5,020 | 0.907 | 20 | +| トレーダーBがtoken0を10入金し、token1を8.984受け取る | 1,060.000 | 943.396 | 5,030 | 0.890 | 20+10\*0.907 = 29.07 | +| トレーダーCがtoken0を40入金し、token1を34.305受け取る | 1,100.000 | 909.090 | 5,100 | 0.826 | 29.07+70\*0.890 = 91.37 | +| トレーダーDがtoken1を100入金し、token0を109.01受け取る | 990.990 | 1,009.090 | 5,110 | 1.018 | 91.37+10\*0.826 = 99.63 | +| トレーダーEがtoken0を10入金し、token1を10.079受け取る | 1,000.990 | 999.010 | 5,150 | 0.998 | 99.63+40\*1.1018 = 143.702 | -タイムスタンプ5,030から5,150の間の**Token0**の平均価格を計算してみましょう。 `price0Cumulative`の値の差は、143.702-29.07=114.632です。 これは2分間(120秒)の平均値です。 つまり、平均価格は114.632/120 = 0.955となります。 +タイムスタンプ5,030から5,150の間の**Token0**の平均価格を計算してみましょう。 `price0Cumulative`の値の差は、143.702-29.07=114.632です。 これは2分間(120秒)の平均値です。 つまり、平均価格は114.632/120 = 0.955となります。 古いリザーブサイズを把握しておく必要があるのは、この価格計算のためです。 @@ -385,7 +388,7 @@ balance0またはbalance1(uint256)が、uint112(-1) (=2^112-1)よりも大きい } ``` -最後に、グローバル変数をアップデートし、`Sync`イベントを発行します。 +最後に、グローバル変数を更新し、`Sync`イベントを発行します。 ##### \_mintFee @@ -394,29 +397,30 @@ balance0またはbalance1(uint256)が、uint112(-1) (=2^112-1)よりも大きい function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) { ``` -Uniswap 2.0で、トレーダーは、マーケットの利用料として0.30%のフィーを払います。 フィーの大半は、流動性プロバイダーに支払われます(取引の0.25%)。 残りの0.05%は、流動性プロバイダーまたは、プロトコルフィーとしてファクトリで指定されたアドレスへ送られます。プロトコルフィーは、Uniswapの開発のために支払われます。 +Uniswap 2.0では、トレーダーは市場の利用料として0.30%の手数料を支払います。 その手数料のほとんど(取引の0.25%)は、常に流動性プロバイダーに支払われます。 残りの0.05%は、流動性プロバイダーまたは、プロトコル手数料としてファクトリで指定されたアドレスへ送られます。このプロトコル手数料は、Uniswapの開発努力に対して支払われます。 -計算量(それに伴うガス代)を削減するため、このフィーは、トランザクションごとではなく、プールから流動性が追加または削除されるときだけ計算されます。 +計算量(およびそれに伴うガス代)を削減するため、この手数料は、トランザクションごとではなく、プールから流動性が追加または削除されるときだけ計算されます。 ```solidity address feeTo = IUniswapV2Factory(factory).feeTo(); feeOn = feeTo != address(0); ``` -上記コードのファクトリーのフィー送信先を読んでみましょう。 ゼロの場合、プロトコルフィーはかからず、フィーを計算する必要もありません。 +ファクトリーの手数料送信先を読み取ります。 ゼロの場合、プロトコル手数料はかからず、その手数料を計算する必要もありません。 ```solidity uint _kLast = kLast; // gas savings ``` -`kLast`状態変数はストレージに位置しているため、コントラクトへの異なる呼び出し間で値を持つことになります。 ストレージへのアクセスは、コントラクトへの関数呼び出しが終了したときにリリースされる揮発メモリへのアクセスよりも非常に高価となるため、内部変数を使ってガス代を節約します。 +`kLast`状態変数はストレージに格納されているため、コントラクトへの異なる呼び出し間で値を持ちます。 +ストレージへのアクセスは、コントラクトへの関数呼び出しが終了したときに解放される揮発性メモリへのアクセスよりもはるかに高価なため、内部変数を使ってガス代を節約します。 ```solidity if (feeOn) { if (_kLast != 0) { ``` -流動性プロバイダーは、流動性トークンの価値が上昇するだけで取り分をもらえます。 一方、プロトコルフィーは、新しい流動性トークンをミントし、`feeTo`アドレスに提供する必要があります。 +流動性プロバイダーは、流動性トークンの価値が上昇するだけで取り分を得られます。 しかし、プロトコル手数料には、新しい流動性トークンをミントし、`feeTo`アドレスに提供する必要があります。 ```solidity uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1)); @@ -424,7 +428,7 @@ Uniswap 2.0で、トレーダーは、マーケットの利用料として0.30% if (rootK > rootKLast) { ``` -プロトコルフィーを徴収する新しい流動性がある場合の 平方根関数については、この[記事の後半](#Math)で解説します。 +プロトコル手数料を徴収する新しい流動性がある場合です。 平方根関数については、[この記事の後半](#Math)で説明します。 ```solidity uint numerator = totalSupply.mul(rootK.sub(rootKLast)); @@ -432,7 +436,7 @@ Uniswap 2.0で、トレーダーは、マーケットの利用料として0.30% uint liquidity = numerator / denominator; ``` -このフィーの複雑な計算方法については、[ホワイトペーパー](https://uniswap.org/whitepaper.pdf)の5ページ目で説明されています。 (流動性が実際に変化する前に、流動性が追加または削除されるたびにこの計算を実行するため、)`kLast`が計算された時間から現在までの間に流動性が追加または削除されていないことがわかります。そのため、`reserve0 * reserve1`の変更は、トランザクションフィーに起因する必要があります。 (流動性の追加または削除がなければ、`reserve0 * reserve1`を一定に保ちます)。 +この複雑な手数料の計算方法については、[ホワイトペーパー](https://app.uniswap.org/whitepaper.pdf)の5ページ目で説明されています。 `kLast`が計算された時から現在までの間に流動性が追加または削除されていないことがわかります (なぜなら、流動性が実際に変化する前に、流動性が追加または削除されるたびにこの計算を実行するため)。そのため、`reserve0 * reserve1`の変更は、トランザクション手数料に起因する必要があります (それがなければ、`reserve0 * reserve1`は一定に保たれます)。 ```solidity if (liquidity > 0) _mint(feeTo, liquidity); @@ -449,26 +453,27 @@ Uniswap 2.0で、トレーダーは、マーケットの利用料として0.30% } ``` -フィーがない場合、`kLast`がゼロでなければゼロに設定します。 このコントラクトが書かれたとき、[ガス払い戻し機能](https://eips.ethereum.org/EIPS/eip-3298)がありました。この機能は、コントラクトによって必要のないストレージをゼロにすることで、イーサリアム全体のサイズを縮小するよう促したものです。 この機能により、可能な場合はコードは払い戻しを受けます。 +手数料がない場合、`kLast`がゼロでなければゼロに設定します。 このコントラクトが書かれたとき、[ガス払い戻し機能](https://eips.ethereum.org/EIPS/eip-3298)がありました。この機能は、コントラクトが不要なストレージをゼロにすることで、イーサリアム全体のステートサイズを縮小するよう促すものでした。 +このコードは、可能な場合にその払い戻しを受けます。 -#### 外部アクセス可能な関数 {#pair-external} +#### 外部からアクセス可能な関数 {#pair-external} -どのトランザクションまたはコントラクトでも、これらの関数を呼び出すことは_できます_が、ペリフェリーコントラクトから呼び出されるように設計されていることに注意してください。 直接呼び出すと、ペア取引所で不正行為はできませんが、誤って価値を失ってしまう可能性があります。 +どのトランザクションまたはコントラクトでもこれらの関数を呼び出すことはできますが、ペリフェリーコントラクトから呼び出されるように設計されていることに注意してください。 直接呼び出すと、ペア取引所で不正行為はできませんが、誤って価値を失ってしまう可能性があります。 -##### mint +##### ミント ```solidity // this low-level function should be called from a contract which performs important safety checks function mint(address to) external lock returns (uint liquidity) { ``` -この関数は、流動性プロバイダーが流動性をプールへ追加するときに呼び出されます。 報酬として追加の流動性トークンをミントします。 同じトランザクションで流動性を追加した後に呼び出す[ペリフェリーコントラクト](#UniswapV2Router02)から呼び出されます。(そうすることで、誰もが正当な所有者より前に、新しい流動性を要求するトランザクションの送信ができなくなります。) +この関数は、流動性プロバイダーが流動性をプールへ追加するときに呼び出されます。 報酬として追加の流動性トークンをミントします。 同じトランザクションで流動性を追加した後にそれを呼び出す[ペリフェリーコントラクト](#UniswapV2Router02)から呼び出されるべきです(そうすることで、他の誰もが正当な所有者より前に、新しい流動性を要求するトランザクションを送信できなくなります)。 ```solidity (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings ``` -これは、Solidity関数が返す複数の戻り値を読み取る方法です。 最後に返された値のブロックのタイムスタンプは必要ないため、破棄します。 +これは、複数の値を返すSolidity関数の結果を読み取る方法です。 最後に返された値であるブロックのタイムスタンプは必要ないため、破棄します。 ```solidity uint balance0 = IERC20(token0).balanceOf(address(this)); @@ -477,50 +482,51 @@ Uniswap 2.0で、トレーダーは、マーケットの利用料として0.30% uint amount1 = balance1.sub(_reserve1); ``` -現在の残高を取得し、各トークンタイプで追加された値を確認します。 +現在の残高を取得し、各トークンタイプでいくら追加されたかを確認します。 ```solidity bool feeOn = _mintFee(_reserve0, _reserve1); ``` -プロトコルフィーを計算して収集し、それに応じて流動性トークンをミントします。 `_mintFee`のパラメータは古いリザーブ値であるため、フィーによるプールの変更にのみ基づいてフィーは正確に計算されます +収集すべきプロトコルフィーがあれば計算し、それに応じて流動性トークンをミントします。 `_mintFee`のパラメータは古いリザーブ値であるため、フィーは、フィーによるプールの変更のみに基づいて正確に計算されます。 ```solidity - uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee + uint _totalSupply = totalSupply; // ガス代節約のため、totalSupplyは_mintFeeで更新される可能性があるため、ここで定義する必要があります if (_totalSupply == 0) { liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY); - _mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens + _mint(address(0), MINIMUM_LIQUIDITY); // 最初のMINIMUM_LIQUIDITYトークンを永久にロックします ``` -これが最初の入金の場合は、`MINIMUM_LIQUIDITY`トークンを作成し、それらをロックするためにゼロアドレスに送信します。 このトークンは引き換えることができないため、プールが完全に空になることはありません(これによりゼロ除算を防ぎます) 。 `MINIMUM_LIQUIDITY`の値は、1000です。これは、ETHがwei単位に分割されるように、ほとんどのERC-20がトークンの10の18乗の単位に分割されることを考慮して、単一トークンの値の10^-15となっており、 高コストではありません。 +これが最初の入金である場合は、`MINIMUM_LIQUIDITY`トークンを作成し、それらをロックするためにゼロアドレスに送信します。 それらは償還できないため、プールが完全に空になることはありません(これにより、いくつかの箇所でゼロによる除算を回避できます)。 `MINIMUM_LIQUIDITY`の値は1000です。ETHがweiに分割されるように、ほとんどのERC-20はトークンの10^-18乗の単位に細分化されることを考えると、これは単一トークンの価値の10^-15に相当します。 高コストではありません。 -最初の入金の時点では、2つのトークンの相対的価値はわからないため、金額を掛けて平方根をとります。入金によって両方のトークンの価値が等しくなったと仮定します。 +最初の入金時点では、2つのトークンの相対的価値が不明なため、金額を掛けて平方根を求めます。入金によって両方のトークンに同等の価値が提供されると仮定します。 -裁定取引で価値の喪失を防ぎ、同等の価値を提供することが入金者の利益になるため、信頼することができます。 例えば、2つのトークンの価値が同等であるものの、入金者が**Token0**の4倍の**Token1**を入金したとします。 トレーダーは、価値を抽出するために、ペア取引所が**Token0**の価値の方が高いと考えている事実を利用することができます。 +裁定取引で価値を失うのを避け、同等の価値を提供することが預金者の利益になるため、これは信頼できます。 +2つのトークンの価値が同一であると仮定しますが、預金者は**Token0**の4倍の**Token1**を預け入れました。 トレーダーは、ペア取引所が**Token0**の方が価値が高いと考えている事実を利用して、そこから価値を引き出すことができます。 -| イベント | reserve0 | reserve1 | reserve0 \* reserve1 | プールの値(reserve0 + reserve1) | -| ----------------------------------------- | --------:| --------:| ----------------------:| --------------------------:| -| 初期設定 | 8 | 32 | 256 | 40 | -| トレーダーは**Token0**トークンを8入金し、**Token1**を16戻す | 16 | 16 | 256 | 32 | +| イベント | reserve0 | reserve1 | reserve0 \* reserve1 | プールの値(reserve0 + reserve1) | +| ----------------------------------------------- | -------: | -------: | -------------------: | --------------------------------------------: | +| 初期設定 | 8 | 32 | 256 | 40 | +| トレーダーは8つの**Token0**トークンを預け入れ、16の**Token1**を返します | 16 | 16 | 256 | 32 | -上記のように、トレーダーは、プールの価値の減少から追加の8トークンを獲得し、それを所有する入金者に損害を与えました。 +ご覧のように、トレーダーは追加で8トークンを獲得しましたが、これはプールの価値の減少によるもので、それを所有する預金者に損害を与えました。 ```solidity } else { liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1); ``` -その後の入金では、2つのアセットの交換レートがすでにわかっており、流動性プロバイダーが両方のアセットで同等の価値を提供することが期待できます。 そうしなかった場合、罰として、提供された流動性より低い価値の流動性トークンが与えられます。 +その後のすべての預金で、2つの資産間の為替レートはすでに分かっており、流動性プロバイダーが両方で同等の価値を提供することを期待しています。 そうしない場合は、罰として、提供された価値よりも低い流動性トークンを与えます。 -初回の入金であれ、その後の入金であれ、提供する流動性トークンの数は、 `reserve0*reserve1`の変化の平方根に等しくなり、(「罰金」の対象となる両方のトークンの種類で同等の価値ではない入金をしないかぎり) 流動性トークンの価値は変化しません。 もう1つ、同等の価値を持つ2つのトークンの例をご紹介します。3つが良い入金で、1つが(1種類のトークンのみを入金するため、流動性トークンは生成されない)悪い入金です。 +初回入金であろうと、その後の入金であろうと、私たちが提供する流動性トークンの数は、`reserve0*reserve1`の変化の平方根に等しく、流動性トークンの価値は変わりません(両方のタイプで同等の価値を持たない入金があった場合を除き、その場合は「罰金」が分配されます)。 ここにもう1つ、同じ価値を持つ2つのトークンの例を示します。3つが良い入金で、1つが悪い入金です(1種類のトークンのみの入金なので、流動性トークンは生成されません)。 -| イベント | reserve0 | reserve1 | reserve0 \* reserve1 | プール値(reserve0 + reserve1) | この入金でミントされた流動性トークン | 流動性トークンの合計 | 各流動性トークンの価値 | -| --------- | --------:| --------:| ----------------------:| -------------------------:| ------------------:| ----------:| -----------:| -| 初期設定 | 8.000 | 8.000 | 64 | 16.000 | 8 | 8 | 2.000 | -| 各種4つずつ入金 | 12.000 | 12.000 | 144 | 24.000 | 4 | 12 | 2.000 | -| 各種2つずつ入金 | 14.000 | 14.000 | 196 | 28.000 | 2 | 14 | 2.000 | -| 等しくない値を入金 | 18.000 | 14.000 | 252 | 32.000 | 0 | 14 | ~2.286 | -| 裁定取引後 | ~15.874 | ~15.874 | 252 | ~31.748 | 0 | 14 | ~2.267 | +| イベント | reserve0 | reserve1 | reserve0 \* reserve1 | プール値(reserve0 + reserve1) | この入金でミントされた流動性トークン | 流動性トークン合計 | 各流動性トークンの価値 | +| --------- | ----------------------: | ----------------------: | -------------------: | -------------------------------------------: | -----------------: | --------: | ---------------------: | +| 初期設定 | 8.000 | 8.000 | 64 | 16.000 | 8 | 8 | 2.000 | +| 各種4つずつ入金 | 12.000 | 12.000 | 144 | 24.000 | 4 | 12 | 2.000 | +| 各種2つずつ入金 | 14.000 | 14.000 | 196 | 28.000 | 2 | 14 | 2.000 | +| 等しくない値を入金 | 18.000 | 14.000 | 252 | 32.000 | 0 | 14 | 〜2.286 | +| 裁定取引後 | 〜15.874 | 〜15.874 | 252 | 〜31.748 | 0 | 14 | 〜2.267 | ```solidity } @@ -533,42 +539,43 @@ Uniswap 2.0で、トレーダーは、マーケットの利用料として0.30% ```solidity _update(balance0, balance1, _reserve0, _reserve1); - if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date + if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0とreserve1は最新の状態です emit Mint(msg.sender, amount0, amount1); } ``` -状態変数(`reserve0`、`reserve1`、必要に応じて`kLast`)をアップデートし、必要であれば適切なイベントを発行します。 +状態変数(`reserve0`、`reserve1`、必要に応じて`kLast`)を更新し、適切なイベントを発行します。 ##### burn ```solidity - // this low-level function should be called from a contract which performs important safety checks + // この低レベル関数は、重要な安全確認を行うコントラクトから呼び出す必要があります function burn(address to) external lock returns (uint amount0, uint amount1) { ``` -この関数は、流動性が引き出され、適切な流動性トークンをバーンする必要がある場合に呼び出されます。 また、[ペリフェリーコントラクトから](#UniswapV2Router02)も呼び出されるようになっています。 +この関数は、流動性が引き出され、適切な流動性トークンをバーンする必要がある場合に呼び出されます。 +また、[ペリフェリーアカウント](#UniswapV2Router02)からも呼び出される必要があります。 ```solidity - (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings - address _token0 = token0; // gas savings - address _token1 = token1; // gas savings + (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // ガス節約 + address _token0 = token0; // ガス節約 + address _token1 = token1; // ガス節約 uint balance0 = IERC20(_token0).balanceOf(address(this)); uint balance1 = IERC20(_token1).balanceOf(address(this)); uint liquidity = balanceOf[address(this)]; ``` -ペリフェリーコントラクトは、呼び出し前に、このコントラクトにバーンされる流動性を送信します。 これにより、バーンされる流動性の量を把握でき、確実にバーンすることができます。 +ペリフェリーコントラクトは、呼び出しの前に、このコントラクトにバーンされる流動性を転送します。 これにより、バーンする流動性の量を把握し、確実にバーンされることを確認できます。 ```solidity bool feeOn = _mintFee(_reserve0, _reserve1); - uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee - amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution - amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution + uint _totalSupply = totalSupply; // ガス節約のため、totalSupplyは_mintFeeで更新される可能性があるため、ここで定義する必要があります + amount0 = liquidity.mul(balance0) / _totalSupply; // 残高を使用することで比例配分を保証します + amount1 = liquidity.mul(balance1) / _totalSupply; // 残高を使用することで比例配分を保証します require(amount0 > 0 && amount1 > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED'); ``` -流動性プロバイダーは、両方のトークンで同等の価値を受け取り、 交換レートを変更することもありません。 +流動性プロバイダーは、両方のトークンの同等の価値を受け取ります。 これにより、交換レートを変更しません。 ```solidity _burn(address(this), liquidity); @@ -578,44 +585,45 @@ Uniswap 2.0で、トレーダーは、マーケットの利用料として0.30% balance1 = IERC20(_token1).balanceOf(address(this)); _update(balance0, balance1, _reserve0, _reserve1); - if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date + if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0とreserve1は最新です emit Burn(msg.sender, amount0, amount1, to); } ``` -`burn`関数の残りの部分は、`mint`関数が逆(ミラーイメージ)になったものです。 +`burn`関数の残りの部分は、上記の`mint`関数と鏡写しの関係にあります。 ##### swap ```solidity - // this low-level function should be called from a contract which performs important safety checks + // この低レベル関数は、重要な安全確認を行うコントラクトから呼び出す必要があります function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock { ``` -この関数は、 [ペリフェリーコントラクト](#UniswapV2Router02)からも呼び出されることになっています。 +この関数も[ペリフェリーコントラクト](#UniswapV2Router02)から呼び出されることになっています。 ```solidity require(amount0Out > 0 || amount1Out > 0, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT'); - (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings + (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // ガス節約 require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: INSUFFICIENT_LIQUIDITY'); uint balance0; uint balance1; - { // scope for _token{0,1}, avoids stack too deep errors + { // _token{0,1}のスコープ、スタックが深すぎるエラーを回避 ``` -ローカル変数は、メモリに保存するか、少ない場合は直接スタック上に保存できます。 数を制限できれば、ガスの使用量が少ないスタックを使用することができます。 詳細については、[正式なイーサリアム仕様であるイエロー ペーパー](https://ethereum.github.io/yellowpaper/paper.pdf)の26ページ目に記載されている等式298をご覧ください。 +ローカル変数はメモリに保存するか、数が多すぎない場合は直接スタックに保存できます。 +スタックを使用できるように数を制限すれば、ガスの使用量を削減できます。 詳細については、[正式なイーサリアムの仕様であるイエローペーパー](https://ethereum.github.io/yellowpaper/paper.pdf)の26ページ、式298を参照してください。 ```solidity address _token0 = token0; address _token1 = token1; require(to != _token0 && to != _token1, 'UniswapV2: INVALID_TO'); - if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens - if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens + if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // 楽観的にトークンを転送 + if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // 楽観的にトークンを転送 ``` -この送金は、すべての条件が満たされていることを確認する前に行っているため、楽観的です。 これはイーサリアムでは、問題ありません。呼び出しの後半で、条件を満たしていなければ、作成されたすべての変更が戻されるからです。 +この転送は、すべての条件が満たされていることを確認する前に転送するため、楽観的です。 これはイーサリアムでは問題ありません。なぜなら、呼び出しの後半で条件が満たされない場合、そこから元に戻され、作成された変更もすべて元に戻されるからです。 ```solidity if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data); @@ -629,19 +637,19 @@ Uniswap 2.0で、トレーダーは、マーケットの利用料として0.30% } ``` -現在の残高を取得します。 ペリフェリーコントラクトは、スワップを呼び出す前にトークンを送信するため、 コントラクトで不正行為がされていないことを簡単に確認できるようになります。このチェックは、ペリフェリーコントラクト以外のエンティティから呼び出される可能性があるため、コアコントラクトで_実行しなければなりません_。 +現在の残高を取得します。 ペリフェリーコントラクトは、スワップを呼び出す前にトークンを送信します。 これにより、コントラクトは不正行為がないことを簡単に確認できます。このチェックは、コアコントラクトで行う_必要_があります(なぜなら、ペリフェリーコントラクト以外のエンティティからも呼び出される可能性があるため)。 ```solidity uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0; uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0; require(amount0In > 0 || amount1In > 0, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT'); - { // scope for reserve{0,1}Adjusted, avoids stack too deep errors + { // reserve{0,1}Adjustedのスコープ、スタックが深すぎるエラーを回避 uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3)); uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3)); require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: K'); ``` -これは、スワップによる損失を確実に防ぐサニティチェックです。 スワップによって`reserve0*reserve1`が減少することはありません。 これは、スワップで0.3%のフィーが送信されることを保証する場所でもあります。K値のサニティチェックをする前に、両方の残高に1000を掛け、3を掛けた金額を引きます。これは現在のリザーブのK値と比較する前に、残高から0.3%(3/1000 = 0.003 = 0.3%)が差し引かれることを意味します。 +これは、スワップによる損失がないことを確認するためのサニティチェックです。 いかなる状況でも、スワップによって`reserve0*reserve1`が減少することはありません。 これは、スワップで0.3%の手数料が送信されることを保証する場所でもあります。K値のサニティチェックをする前に、両方の残高に1000を掛け、3を掛けた金額を引きます。これは、現在のリザーブのK値と比較する前に、残高から0.3%(3/1000 = 0.003 = 0.3%)が差し引かれることを意味します。 ```solidity } @@ -651,29 +659,30 @@ Uniswap 2.0で、トレーダーは、マーケットの利用料として0.30% } ``` -`reserve0`と`reserve1`をアップデートし、必要に応じて価格アキュムレータとタイムスタンプもアップデートして、イベントを発行します。 +`reserve0`と`reserve1`を更新し、必要に応じて価格アキュムレータとタイムスタンプも更新して、イベントを発行します。 -##### syncまたはskim +##### SyncまたはSkim -実際の残高とペア取引所が持っているとされるリザーブとが一致しない可能性があります。 コントラクトの同意なしにトークンを引き出すことはできませんが、入金は可能です。 アカウントは、 `mint`または`swap`どちらかを呼び出すことなくトークンを取引所に送信することができます。 +実際の残高が、ペア取引所が持っていると考えるリザーブと同期しなくなる可能性があります。 +コントラクトの同意なしにトークンを引き出す方法はありませんが、入金は別の問題です。 アカウントは、`mint`または`swap`のいずれかを呼び出すことなくトークンを取引所に転送できます。 -このケースでは次の2つの解決策があります。 +その場合、2つの解決策があります。 -- `sync`でリザーブを現在の残高にアップデートします。 -- `skim`で余分な金額を引き出します。 誰がトークンを入金したか分からないため、どのアカウントでも`skim`の呼び出しが許可されていることに注意してください。 この情報はイベント内で発行されますが、イベントはブロックチェーンからはアクセスできません。 +- `sync`、リザーブを現在の残高に更新します。 +- `skim`、余分な金額を引き出します。 誰がトークンを入金したか不明なため、どのアカウントでも`skim`を呼び出せることに注意してください。 この情報はイベント内で発行されますが、イベントはブロックチェーンからはアクセスできません。 ```solidity - // force balances to match reserves + // 残高をリザーブに一致させる function skim(address to) external lock { - address _token0 = token0; // gas savings - address _token1 = token1; // gas savings + address _token0 = token0; // ガス節約 + address _token1 = token1; // ガス節約 _safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0)); _safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1)); } - // force reserves to match balances + // リザーブを残高に一致させる function sync() external lock { _update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1); } @@ -682,7 +691,7 @@ Uniswap 2.0で、トレーダーは、マーケットの利用料として0.30% ### UniswapV2Factory.sol {#UniswapV2Factory} -[このコントラクト](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Factory.sol)では、ペア取引所を作ります。 +[このコントラクト](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Factory.sol)はペア取引所を作成します。 ```solidity pragma solidity =0.5.16; @@ -695,26 +704,27 @@ contract UniswapV2Factory is IUniswapV2Factory { address public feeToSetter; ``` -これらの状態変数はプロトコルフィーを実装するために必要です。詳細は、[ホワイトペーパー](https://uniswap.org/whitepaper.pdf)の5ページ目をご覧ください。 `feeTo`は、プロトコルフィーのための流動性トークンを蓄積するアドレスで、`feeToSetter`は、`feeTo`を別のアドレスに変更できるアドレスです。 +これらの状態変数は、プロトコルフィーを実装するために必要です([ホワイトペーパー](https://app.uniswap.org/whitepaper.pdf)の5ページ参照)。 +`feeTo`アドレスはプロトコルフィーのための流動性トークンを蓄積し、`feeToSetter`は`feeTo`を別のアドレスに変更できるアドレスです。 ```solidity mapping(address => mapping(address => address)) public getPair; address[] public allPairs; ``` -これらの変数は、ペアと2種類のトークン間の取引を追跡します。 +これらの変数は、ペア、つまり2種類のトークン間の交換を追跡します。 -最初の`getPair`は、交換する2つのERC-20トークンに基づいてペア取引所コントラクトを識別するマッピングです。 ERC-20トークンは、それらを実装するコントラクトのアドレスによって特定されるため、キーと値はすべてアドレスです。 `tokenA`から`tokenB`に交換するペア取引所のアドレスを取得するために、 `getPair[][]`を使います(逆の場合も同様) 。 +1つ目の`getPair`は、交換する2つのERC-20トークンに基づいてペア取引所コントラクトを識別するマッピングです。 ERC-20トークンは、それらを実装するコントラクトのアドレスによって識別されるため、キーと値はすべてアドレスです。 `tokenA`から`tokenB`に変換できるペア取引所のアドレスを取得するには、`getPair[][]`を使用します(またはその逆)。 -2つ目の変数`allPairs`は、このファクトリーによって作られたすべてのペア取引所のアドレスを含む配列です。 イーサリアムでは、マッピング内容のイテレートやすべてのキーのリストを取得することはできないので、この変数が、ファクトリーが管理する取引所を知る唯一の方法となります。 +2つ目の変数`allPairs`は、このファクトリーによって作成されたすべてのペア取引所のアドレスを含む配列です。 イーサリアムでは、マッピングのコンテンツを反復処理したり、すべてのキーのリストを取得したりすることはできないため、この変数が、このファクトリーがどの取引所を管理しているかを知る唯一の方法となります。 -注: マッピングのすべてのキーをイテレートできない理由は、コントラクトのデータストレージが_高額_であるため、使用量が少ないほど良く、変更頻度が少ないほど良いからです。 [イテレーションをサポートするマッピング](https://github.com/ethereum/dapp-bin/blob/master/library/iterable_mapping.sol)の作成もできますが、キーのリストのために追加のストレージが必要です。 通常、ほとんどのアプリケーションで必要ありません。 +注: マッピングのすべてのキーを反復処理できない理由は、コントラクトのデータストレージが高価であるため、使用量が少ないほど良く、変更頻度が少ないほど良いからです。 [反復をサポートするマッピング](https://github.com/ethereum/dapp-bin/blob/master/library/iterable_mapping.sol)を作成することもできますが、キーのリストのために追加のストレージが必要です。 ほとんどのアプリケーションでは、それは必要ありません。 ```solidity event PairCreated(address indexed token0, address indexed token1, address pair, uint); ``` -このイベントは、新しいペア取引所が作成されたときに発行されます。 トークンのアドレス、ペア取引所のアドレス、ファクトリーによって管理されている全取引所の数が含まれます。 +このイベントは、新しいペア取引所が作成されたときに発行されます。 これには、トークンのアドレス、ペア取引所のアドレス、およびファクトリーによって管理される取引所の総数が含まれます。 ```solidity constructor(address _feeToSetter) public { @@ -722,7 +732,7 @@ contract UniswapV2Factory is IUniswapV2Factory { } ``` -コンストラクタが行う唯一のことは、`feeToSetter`を指定することです。 ファクトリーはフィーなしで開始し、変更できるのは`feeSetter`のみとなります。 +コンストラクタが行う唯一のことは、`feeToSetter`を指定することです。 ファクトリーは手数料なしで開始し、`feeSetter`のみがそれを変更できます。 ```solidity function allPairsLength() external view returns (uint) { @@ -730,33 +740,35 @@ contract UniswapV2Factory is IUniswapV2Factory { } ``` -この関数は、取引ペアの数を返します。 +この関数は、交換ペアの数を返します。 ```solidity function createPair(address tokenA, address tokenB) external returns (address pair) { ``` -これはファクトリーのメイン関数で、ERC-20トークン間のペア取引所を作成します。 誰でもこの関数を呼び出せることに注意してください。 新しいペア取引所を作成するのにUniswapからの許可は必要ありません。 +これはファクトリーの主な機能で、2つのERC-20トークン間のペア取引所を作成します。 誰でもこの関数を呼び出せることに注意してください。 新しいペア取引所を作成するのにUniswapからの許可は必要ありません。 ```solidity require(tokenA != tokenB, 'UniswapV2: IDENTICAL_ADDRESSES'); (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); ``` -新しい取引所のアドレスを決定的にできるよう、事前にオフチェーンで計算できるようになっており (これは[レイヤー2トランザクション](/developers/docs/layer-2-scaling/)で役立ちます) 、 そうするためには、受け取った順序に関わらずトークンアドレスの順序に一貫性を持たせる必要があります。並べ替えているのは、こうした理由からです。 +新しい取引所のアドレスは決定論的である必要があるため、オフチェーンで事前に計算できます(これは[レイヤー2トランザクション](/developers/docs/scaling/)に役立ちます)。 +これを行うには、トークンアドレスの順序が受け取った順序に関わらず一貫している必要があるため、ここで並べ替えます。 ```solidity require(token0 != address(0), 'UniswapV2: ZERO_ADDRESS'); - require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS'); // single check is sufficient + require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS'); // 1回のチェックで十分です ``` -大きな流動性プールは価格がより安定するため、小さなものよりも優れています。 トークンのペアに対して流動性プールを1つ以上持たないようにします。 すでに取引所が存在する場合、同じペアに対して別の取引所を作る必要がないからです。 +大きな流動性プールは価格がより安定するため、小さなものよりも優れています。 トークンのペアごとに複数の流動性プールを持つことは望ましくありません。 すでに取引所が存在する場合、同じペアに対して別の取引所を作成する必要はありません。 ```solidity bytes memory bytecode = type(UniswapV2Pair).creationCode; ``` -新しいコントラクトを作成するには、作成するコードが必要です(コンストラクタ関数と、実際のコントラクトのEVMバイトコードをメモリに書き込むコードの両方) 。 通常、Solidityで`addr = new ()`を使うだけで、コンパイラは全ての処理を実行しますが、決定的なコントラクトアドレスを取得するには、[CREATE2オペコード](https://eips.ethereum.org/EIPS/eip-1014)を使用する必要があります。 このコードが書かれた時点では、このオペコードはSolidityではサポートされていなかったため、コードを手動で実行する必要がありましたが、 [現在SolidityはCREATE2をサポートしている](https://docs.soliditylang.org/en/v0.8.3/control-structures.html#salted-contract-creations-create2)ため、問題ありません。 +新しいコントラクトを作成するには、それを作成するコードが必要です(コンストラクタ関数と、実際のコントラクトのEVMバイトコードをメモリに書き込むコードの両方)。 通常、Solidityでは`addr = new <コントラクト名>(<コンストラクタのパラメータ>)`を使用するだけで、コンパイラがすべてを処理してくれます。しかし、決定的なコントラクトアドレスを持つためには、[CREATE2オペコード](https://eips.ethereum.org/EIPS/eip-1014)を使用する必要があります。 +このコードが書かれた時点では、このオペコードはまだSolidityでサポートされていなかったため、コードを手動で取得する必要がありました。 これはもはや問題ではありません。なぜなら、[Solidityは現在CREATE2をサポートしている](https://docs.soliditylang.org/en/v0.8.3/control-structures.html#salted-contract-creations-create2)からです。 ```solidity bytes32 salt = keccak256(abi.encodePacked(token0, token1)); @@ -765,23 +777,22 @@ contract UniswapV2Factory is IUniswapV2Factory { } ``` -オペコードがSolidityによってサポートされていなかった時は、 [インラインアセンブリ](https://docs.soliditylang.org/en/v0.8.3/assembly.html)を使って呼び出していました。 +オペコードがまだSolidityでサポートされていない場合、[インラインアセンブリ](https://docs.soliditylang.org/en/v0.8.3/assembly.html)を使用して呼び出すことができます。 ```solidity IUniswapV2Pair(pair).initialize(token0, token1); ``` -`initialize`関数を呼び出して、新しい取引所に交換する2つのトークンの種類を伝えます。 +`initialize`関数を呼び出して、新しい取引所にどの2つのトークンを交換するかを伝えます。 ```solidity getPair[token0][token1] = pair; - getPair[token1][token0] = pair; // populate mapping in the reverse direction + getPair[token1][token0] = pair; // 逆方向のマッピングを設定 allPairs.push(pair); emit PairCreated(token0, token1, pair, allPairs.length); - } ``` -状態変数に新しいペアの情報を保存し、イベントを発行することで、新しいペア取引所を全世界に周知します。 +新しいペア情報を状態変数に保存し、イベントを発行して世界に新しいペア取引所を知らせます。 ```solidity function setFeeTo(address _feeTo) external { @@ -796,13 +807,14 @@ contract UniswapV2Factory is IUniswapV2Factory { } ``` -これらの2つの関数は、 `feeSetter`にフィーの受取人を(必要に応じて)制御し、 `feeSetter`を新しいアドレスに変更できます。 +これら2つの関数により、`feeSetter`は手数料の受取人(もしあれば)を制御し、`feeSetter`を新しいアドレスに変更できます。 ### UniswapV2ERC20.sol {#UniswapV2ERC20} -[このコントラクト](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)は、ERC-20流動性トークンを実装しています。 [OpenZeppelin ERC-20コントラクト](/developers/tutorials/erc20-annotated-code)と類似しているので、異なる箇所である`permit`の機能についてのみ説明します。 +[このコントラクト](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)は、ERC-20流動性トークンを実装します。 [OpenZeppelin ERC-20コントラクト](/developers/tutorials/erc20-annotated-code)と類似しているので、異なる部分である`permit`機能についてのみ説明します。 -イーサリアムでのトランザクションでは、現実のお金に相当するイーサ(ETH)のコストがかかります。 ETHではないERC-20トークンを持っていても、トランザクションを送信することができないため役に立ちません。 この問題を回避する解決策の1つが、[メタトランザクション](https://docs.uniswap.org/contracts/v2/guides/smart-contract-integration/supporting-meta-transactions)です。 トークンの所有者がトランザクションに署名することで、第三者がチェーンからトークンを引き出したり、インターネットを使って受信者へ送信したりすることができます。 ETHを持っている受信者が、所有者の代わりに許可を送信します 。 +イーサリアムでのトランザクションには、現実のお金に相当するイーサ(ETH)のコストがかかります。 ERC-20トークンを持っていてもETHを持っていない場合、トランザクションを送信できないため、何もできません。 この問題を回避するための1つの解決策が[メタトランザクション](https://docs.uniswap.org/contracts/v2/guides/smart-contract-integration/supporting-meta-transactions)です。 +トークンの所有者は、他の誰かがオフチェーンでトークンを引き出すことを許可するトランザクションに署名し、インターネットを使用して受信者に送信します。 ETHを持っている受信者が、所有者の代わりに許可を送信します。 ```solidity bytes32 public DOMAIN_SEPARATOR; @@ -810,13 +822,13 @@ contract UniswapV2Factory is IUniswapV2Factory { bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9; ``` -このハッシュは、 [トランザクションタイプのための識別子](https://eips.ethereum.org/EIPS/eip-712#rationale-for-typehash)です。 ここでサポートされているのは、これらのパラメータを持った`Permit`だけです。 +このハッシュは、[トランザクションタイプの識別子](https://eips.ethereum.org/EIPS/eip-712#rationale-for-typehash)です。 ここでサポートされているのは、これらのパラメータを持つ`Permit`だけです。 ```solidity mapping(address => uint) public nonces; ``` -受信者が電子署名を偽造することはできませんが、 同じトランザクションを2回送信することは簡単にできてしまいます(これは[リプレイ攻撃](https://wikipedia.org/wiki/Replay_attack)の形です)。 これを防ぐために、[ノンス](https://wikipedia.org/wiki/Cryptographic_nonce)を使います。 新しい`Permit`のノンスが、最後に使用されたノンスに1を足した数でない場合は無効と見なします。 +受信者がデジタル署名を偽造することは現実的ではありません。 しかし、同じトランザクションを2回送信することは簡単です(これは[リプレイ攻撃](https://wikipedia.org/wiki/Replay_attack)の一種です)。 これを防ぐために、[ノンス](https://wikipedia.org/wiki/Cryptographic_nonce)を使用します。 新しい`Permit`のノンスが、最後に使用されたものより1つ大きくない場合、無効とみなします。 ```solidity constructor() public { @@ -826,7 +838,7 @@ contract UniswapV2Factory is IUniswapV2Factory { } ``` -これは[チェーン識別子](https://chainid.network/)を取得するためのコードで、 [Yul](https://docs.soliditylang.org/en/v0.8.4/yul.html)と呼ばれるEVMアセンブリ方言を使用します。 Yulの現在のバージョンでは、`chainid`ではなく`chainid()`を使用する必要があることに注意してください。 +これは、[チェーン識別子](https://chainid.network/)を取得するためのコードです。 [Yul](https://docs.soliditylang.org/en/v0.8.4/yul.html)と呼ばれるEVMアセンブリ方言を使用します。 現在のバージョンのYulでは、`chainid`ではなく`chainid()`を使用する必要があることに注意してください。 ```solidity DOMAIN_SEPARATOR = keccak256( @@ -838,7 +850,6 @@ contract UniswapV2Factory is IUniswapV2Factory { address(this) ) ); - } ``` EIP-712の[ドメインセパレータ](https://eips.ethereum.org/EIPS/eip-712#rationale-for-domainseparator)を計算します。 @@ -847,13 +858,13 @@ EIP-712の[ドメインセパレータ](https://eips.ethereum.org/EIPS/eip-712#r function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external { ``` -これは、パーミッション(permission)を実装する関数です。 パラメータとして関連するフィールドと[署名](https://yos.io/2018/11/16/ethereum-signatures/)のために3つのスカラー値 (v、r、s) を受け取ります。 +これは、権限を実装する関数です。 パラメータとして関連するフィールドと、[署名](https://yos.io/2018/11/16/ethereum-signatures/)のための3つのスカラー値(v、r、s)を受け取ります。 ```solidity require(deadline >= block.timestamp, 'UniswapV2: EXPIRED'); ``` -期限が過ぎると、トランザクションは受け付けません。 +期限切れのトランザクションは受け付けません。 ```solidity bytes32 digest = keccak256( @@ -865,9 +876,9 @@ EIP-712の[ドメインセパレータ](https://eips.ethereum.org/EIPS/eip-712#r ); ``` -`abi.encodePacked(...)`は、受信を予定しているメッセージです。 私たちはノンスが何であるべきかを認識しているので、パラメータとして取得する必要はありません。 +`abi.encodePacked(...)`は、受信を期待するメッセージです。 ノンスが何であるべきかを私たちは知っているので、パラメータとして取得する必要はありません。 -イーサリアム署名アルゴリズムは、256ビットで署名することになっているため、 `keccak256`ハッシュ関数を使用します。 +イーサリアムの署名アルゴリズムは署名するのに256ビットを期待しているため、`keccak256`ハッシュ関数を使用します。 ```solidity address recoveredAddress = ecrecover(digest, v, r, s); @@ -882,19 +893,20 @@ EIP-712の[ドメインセパレータ](https://eips.ethereum.org/EIPS/eip-712#r ``` -すべて問題なければ、これを[ERC-20承認](https://eips.ethereum.org/EIPS/eip-20#approve)として処理します。 +すべてがOKであれば、これを[ERC-20のapprove](https://eips.ethereum.org/EIPS/eip-20#approve)として扱います。 ## ペリフェリーコントラクト {#periphery-contracts} -ペリフェリーコントラクトは、UniswapのAPI(アプリケーションプログラムインターフェイス) です。 他のコントラクトや分散型アプリケーションから、外部呼び出しで利用可能です。 コアコントラクトは直接呼び出すことができますが、より複雑で間違えると価値を失ってしまう可能性があります。 コアコントラクトには、他者に対する不正行為がないことを確認するためのテストのみが含まれており、サニティチェックは含まれていません。 ペリフェリーコントラクトには含まれており、必要に応じてアップデートすることができます。 +ペリフェリーコントラクトはUniswapのAPI(アプリケーションプログラムインターフェイス)です。 他のコントラクトや分散型アプリケーションからの外部呼び出しで利用可能です。 コアコントラクトを直接呼び出すこともできますが、それはより複雑で、間違いを犯すと価値を失う可能性があります。 コアコントラクトには、自身が不正に操作されていないことを確認するためのテストのみが含まれており、他の誰かのためのサニティチェックは含まれていません。 それらはペリフェリーにあり、必要に応じて更新できます。 ### UniswapV2Router01.sol {#UniswapV2Router01} -[このコントラクト](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/UniswapV2Router01.sol)には問題があるため、[使用してはいけません](https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-01)。 幸いなことに、ペリフェリーコントラクトはステートレスでアセットを保有していないため、非推奨にするのは簡単です。代わりに、`UniswapV2Router02`を使用するよう提案します。 +[このコントラクト](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/UniswapV2Router01.sol)には問題があり、[もはや使用すべきではありません](https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-01)。 幸いなことに、ペリフェリーコントラクトはステートレスで資産を保有していないため、非推奨にし、代わりに後継の`UniswapV2Router02`を使用するよう人々に提案するのは簡単です。 ### UniswapV2Router02.sol {#UniswapV2Router02} -通常は[このコントラクト](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/UniswapV2Router02.sol)を通してUniswapを使用します。 [こちら](https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-02)で使用方法を確認できます。 +ほとんどの場合、[このコントラクト](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/UniswapV2Router02.sol)を通じてUniswapを使用します。 +その使用方法は[こちら](https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-02)で確認できます。 ```solidity pragma solidity =0.6.6; @@ -909,7 +921,7 @@ import './interfaces/IERC20.sol'; import './interfaces/IWETH.sol'; ``` -これらの大半はすでに目にしていると思います。そうでなくても、非常にわかりやすいものです。 唯一の例外は、`IWETH.sol`です。 Uniswap v2は、どのERC-20トークンのペアでも交換可能ですが、イーサ(ETH)自体はERC-20トークンではありません。 ETHは、標準より前から存在しており、独自のメカニズムによって送金されます。 ERC-20トークンが適用されるコントラクトでETHを利用できるようにするため、[ラップドイーサ(WETH)](https://weth.io/)が考案されました。 このコントラクトにETHを送ると、同じ量のWETHがミントされます。 WETHをバーンすると、ETHを取り戻すことができます。 +これらのほとんどは、以前に遭遇したものか、かなり明白なものです。 唯一の例外は`IWETH.sol`です。 Uniswap v2は、どのERC-20トークンのペアでも交換可能ですが、イーサ(ETH)自体はERC-20トークンではありません。 ETHは標準より前から存在しており、独自のメカニズムによって転送されます。 ERC-20トークンに適用されるコントラクトでETHを利用できるようにするため、[ラップされたイーサ(WETH)](https://weth.tkn.eth.limo/)コントラクトが考案されました。 このコントラクトにETHを送ると、同等の量のWETHがミントされます。 または、WETHをバーンしてETHを取り戻すこともできます。 ```solidity contract UniswapV2Router02 is IUniswapV2Router02 { @@ -919,7 +931,7 @@ contract UniswapV2Router02 is IUniswapV2Router02 { address public immutable override WETH; ``` -ルーターは、どのファクトリーを使用するか、WETHを必要とするトランザクションについてはどのWETHコントラクトを使用するかを認識する必要があります。 これらの値は、[不変](https://docs.soliditylang.org/en/v0.8.3/contracts.html#constant-and-immutable-state-variables)であり、コンストラクタでのみ設定できます。 これにより、ユーザーは、不正なコントラクトに変更されることはないという確信を得ることができます。 +ルーターは、どのファクトリーを使用するか、そしてWETHを必要とするトランザクションについてはどのWETHコントラクトを使用するかを知る必要があります。 これらの値は[不変](https://docs.soliditylang.org/en/v0.8.3/contracts.html#constant-and-immutable-state-variables)であり、コンストラクタでのみ設定できます。 これにより、ユーザーは誰もがそれらを変更して、より信頼性の低いコントラクトを指すことができないという確信を得ることができます。 ```solidity modifier ensure(uint deadline) { @@ -928,7 +940,7 @@ contract UniswapV2Router02 is IUniswapV2Router02 { } ``` -この修飾子は、時間制限のあるトランザクション(「可能なときY時の前にXを実行」) が、時間制限後に発生しないようにするものです。 +この修飾子は、時間制限のあるトランザクション(「もしできればY時より前にXを実行する」)が、その時間制限後に発生しないようにします。 ```solidity constructor(address _factory, address _WETH) public { @@ -937,15 +949,15 @@ contract UniswapV2Router02 is IUniswapV2Router02 { } ``` -このコンストラクタは、不変な状態変数を設定しています。 +コンストラクタは、不変な状態変数を設定するだけです。 ```solidity receive() external payable { - assert(msg.sender == WETH); // only accept ETH via fallback from the WETH contract + assert(msg.sender == WETH); // WETHコントラクトからのフォールバック経由でのみETHを受け入れる } ``` -この関数は、トークンをWETHコントラクトからETHに引き換える際に呼び出されます。 私たちが使用しているWETHコントラクトだけが、これを行うことを許可されています。 +この関数は、WETHコントラクトからトークンをETHに引き換える際に呼び出されます。 私たちが使用しているWETHコントラクトだけが、これを行うことを許可されています。 #### 流動性の追加 {#add-liquidity} @@ -953,39 +965,39 @@ contract UniswapV2Router02 is IUniswapV2Router02 { ```solidity - // **** ADD LIQUIDITY **** + // **** 流動性の追加 **** function _addLiquidity( ``` -この関数は、ペア取引所に入金するAトークンとBトークンの量を計算するために使用されます。 +この関数は、ペア取引所に入金すべきAトークンとBトークンの量を計算するために使用されます。 ```solidity address tokenA, address tokenB, ``` -これらは、ERC-20トークンコントラクトのアドレスです。 +これらはERC-20トークンコントラクトのアドレスです。 ```solidity uint amountADesired, uint amountBDesired, ``` -これらは流動性プロバイダーが入金を希望する量であり、 AとBが入金できる最大量でもあります。 +これらは、流動性プロバイダーが預け入れたい金額です。 これらはまた、預け入れられるAとBの最大量でもあります。 ```solidity uint amountAMin, uint amountBMin ``` -これらは受け入れ可能な最低入金量です。 この量以上でトランザクションを実行できない場合は、元に戻します。 この機能を使用しない場合は、ゼロを指定してください。 +これらは、預け入れが許容される最小量です。 トランザクションがこれらの量以上で行われない場合、元に戻されます。 この機能が不要な場合は、ゼロを指定してください。 -流動性プロバイダーは通常、トランザクションを現在の交換レートに近いレートに制限したいため、最小値を指定します。 交換レートの変動が大きすぎると、本来の価値を変更するニュースを意味する可能性があり、こうした状況下では、流動性プロバイダーは手動で対応方法を決定したいと考えます。 +流動性プロバイダーは通常、トランザクションを現在の交換レートに近いレートに制限したいため、最小値を指定します。 為替レートが大きく変動すると、基礎となる価値を変えるニュースを意味する可能性があり、彼らは手動でどうするかを決定したいと考えます。 -例えば、交換レートが1対1で、流動性プロバイダーが次の値を指定するケースを想像してください。 +例えば、為替レートが1対1で、流動性プロバイダーがこれらの値を指定するケースを想像してください。 | パラメータ | 値 | -| -------------- | ----:| +| -------------- | ---: | | amountADesired | 1000 | | amountBDesired | 1000 | | amountAMin | 900 | @@ -993,16 +1005,16 @@ contract UniswapV2Router02 is IUniswapV2Router02 { 交換レートが0.9から1.25の間である限り、トランザクションは行われます。 交換レートがこの範囲から外れると、トランザクションはキャンセルされます。 -この予防措置の理由は、トランザクションが即時ではなく、送信すると最終的にバリデータがそれらをブロックに含めるためです (ガス価格が非常に低い場合を除きます。その場合は、同じノンスでより高いガス価格で別のトランザクションを送信して上書きする必要があります) 。 送信およびトランザクションを含める処理の間で何が起こるかを制御することはできません。 +この予防措置の理由は、トランザクションが即時ではなく、送信すると最終的にバリデータがそれらをブロックに含めるためです(ガス価格が非常に低い場合を除きます。その場合は、同じノンスでより高いガス価格の別のトランザクションを送信して上書きする必要があります)。 送信とトランザクションを含める処理の間で何が起こるかを制御することはできません。 ```solidity ) internal virtual returns (uint amountA, uint amountB) { ``` -この関数は、リザーブ間の現在の比率と同等の比率を持てるよう、流動性プロバイダーが入金すべき量を返します。 +この関数は、流動性プロバイダーが現在の準備金間の比率に等しい比率を持つために預け入れるべき金額を返します。 ```solidity - // create the pair if it doesn't exist yet + // まだ存在しない場合はペアを作成します if (IUniswapV2Factory(factory).getPair(tokenA, tokenB) == address(0)) { IUniswapV2Factory(factory).createPair(tokenA, tokenB); } @@ -1021,14 +1033,14 @@ contract UniswapV2Router02 is IUniswapV2Router02 { (amountA, amountB) = (amountADesired, amountBDesired); ``` -現在のリザーブが空の場合、新しいペア取引所であることがわかります。 流動性プロバイダーが提供したい量とまったく同じ量を入金しなければなりません。 +現在のリザーブが空の場合、これは新しいペア取引所です。 預け入れる金額は、流動性プロバイダーが提供したい金額とまったく同じである必要があります。 ```solidity } else { uint amountBOptimal = UniswapV2Library.quote(amountADesired, reserveA, reserveB); ``` -量を予想する必要がある場合は、[この関数](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/libraries/UniswapV2Library.sol#L35)を使って最適量を取得します。 現在のリザーブと同じ比率が必要です。 +どのくらいの量になるかを確認する必要がある場合は、[この関数](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/libraries/UniswapV2Library.sol#L35)を使用して最適な量を取得します。 現在のリザーブと同じ比率が必要です。 ```solidity if (amountBOptimal <= amountBDesired) { @@ -1036,7 +1048,7 @@ contract UniswapV2Router02 is IUniswapV2Router02 { (amountA, amountB) = (amountADesired, amountBOptimal); ``` -`amountBOptimal`が、流動性プロバイダーが希望する入金の量より小さい場合、つまり現在のトークンBの価値が流動性プロバイダーが考えているものよりも高くなるため、量を減らす必要があります。 +`amountBOptimal`が流動性プロバイダーが預け入れたい金額より小さい場合、それはトークンBが現在、流動性預金者が考えるよりも価値があることを意味し、より少ない金額が必要になります。 ```solidity } else { @@ -1046,13 +1058,13 @@ contract UniswapV2Router02 is IUniswapV2Router02 { (amountA, amountB) = (amountAOptimal, amountBDesired); ``` -Bの最適量がBの希望量よりも大きい場合、現在のBトークンは流動性入金者が考えるよりも価値が低いということになり、量を増やす必要がありますが、 希望量は最大値となっているため、これはできません。 代わりに、Bトークンの希望量に対するAトークンの最適数を計算します。 +Bの最適量が希望のB量よりも多い場合、それはBトークンが現在、流動性預金者が考えるよりも価値が低いことを意味し、より多くの量が必要になります。 しかし、希望量は最大値であるため、それはできません。 代わりに、希望のBトークンの量に対するAトークンの最適数を計算します。 -まとめると、このようなグラフになります。 Aトークンを1000(青線)とBトークンを1000(赤線)を入金しようとしたとします。 X軸は交換レート、A/Bです。 x=1の場合、両者は同じ価値であり、それぞれ1000ずつ入金しています。 x=2の場合、AはBの2倍の価値があるので(Aトークン1つにつき、Bトークン2つが得られる) 、Bトークン1000を入金しても、Aトークンは500にしかなりません。 x=0.5の場合は逆に、Aトークンが1000、Bトークンが500となります。 +まとめると、このグラフになります。 1000のAトークン(青線)と1000のBトークン(赤線)を預け入れようとしていると仮定します。 x軸は交換レートA/Bです。 x=1の場合、それらは同価値であり、それぞれ1000ずつ預け入れます。 x=2の場合、AはBの2倍の価値があるので(各Aトークンに対して2つのBトークンが得られる)、1000のBトークンを預け入れますが、Aトークンは500のみです。 x=0.5の場合、状況は逆になり、1000のAトークンと500のBトークンになります。  -([UniswapV2Pair::mint](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Pair.sol#L110)を使用して、)直接コアコントラクトへ流動性を入金することもできますが、コアコントラクトはそれ自体に不正がないかだけを確認するものであるため、トランザクションの送信から実行までの間に交換レートが変わった場合、価値を喪失するリスクがあります。 ペリフェリーコントラクトを使った場合、即時に入金すべき量を計算し入金します。これにより、交換レートは変わらず何も失うことはありません。 +([UniswapV2Pair::mint](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Pair.sol#L110)を使用して)コアコントラクトに直接流動性を預け入れることもできますが、コアコントラクトは自身が不正に操作されていないかを確認するだけなので、トランザクションを送信してから実行されるまでの間に交換レートが変動すると、価値を失うリスクがあります。 ペリフェリーコントラクトを使用する場合、預け入れるべき金額を計算して即座に預け入れるため、交換レートは変わらず、何も失うことはありません。 ```solidity function addLiquidity( @@ -1066,9 +1078,10 @@ Bの最適量がBの希望量よりも大きい場合、現在のBトークン uint deadline ``` -この関数は、流動性を入金するトランザクションによって呼び出されます。 ほとんどのパラメータは上記の`_addLiquidity`と同じですが、下記に2つの例外をご紹介します。 +この関数は、流動性を預け入れるトランザクションによって呼び出すことができます。 ほとんどのパラメータは上記の`_addLiquidity`と同じですが、2つの例外があります。 -。 `to`はミントされた新しい流動性トークンを取得するアドレスで、流動性プロバイダーのプールの取り分を示します。 `deadline`は、トランザクションの制限時間です。 +。 `to`は、流動性プロバイダーのプールの取り分を示すためにミントされた新しい流動性トークンを取得するアドレスです +。 `deadline`はトランザクションの期限です ```solidity ) external virtual override ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) { @@ -1076,21 +1089,21 @@ Bの最適量がBの希望量よりも大きい場合、現在のBトークン address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB); ``` -実際に入金する量を計算し、流動性プールのアドレスを見つけます。 ガスを節約するために、ファクトリーに依頼するのではなく、ライブラリ関数`pairFor`を使います (ライブラリ内の下記を参照) 。 +実際に預け入れる金額を計算し、流動性プールのアドレスを見つけます。 ガスを節約するために、ファクトリーに問い合わせるのではなく、ライブラリ関数`pairFor`を使用します(以下のライブラリを参照)。 ```solidity TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA); TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB); ``` -適正量のトークンをユーザーからペア取引所に送信します。 +正しい量のトークンをユーザーからペア取引所に転送します。 ```solidity liquidity = IUniswapV2Pair(pair).mint(to); } ``` -代わりに、プールの部分的な所有権のために流動性トークンを`to`アドレスに提供します。 コアコントラクトの`mint`関数は、(最後に流動性が変更されたときと比較して)追加のトークンがいくつあるかを確認し、それに応じて流動性をミントします。 +見返りとして、プールの部分的所有権のために流動性トークンを`to`アドレスに与えます。 コアコントラクトの`mint`関数は、(最後に流動性が変更されたときと比較して)追加のトークンがいくつあるかを確認し、それに応じて流動性をミントします。 ```solidity function addLiquidityETH( @@ -1098,7 +1111,7 @@ Bの最適量がBの希望量よりも大きい場合、現在のBトークン uint amountTokenDesired, ``` -流動性プロバイダーが、トークン/ETHのペア取引所に流動性を提供したい場合は、いくつかの相違点があります。 コントラクトは、ラッピングされたETHで流動性プロバイダーを扱います。 ユーザーはトランザクション時にETHを送金するだけで良いため(量は `msg.value`で確認可能)、入金したいETHの数を指定する必要はありません。 +流動性プロバイダーがトークン/ETHペア取引所に流動性を提供したい場合、いくつかの違いがあります。 コントラクトは、流動性プロバイダーのためにETHのラップを処理します。 ユーザーが預け入れたいETHの量を指定する必要はありません。なぜなら、ユーザーはトランザクションでそれを送るだけであり(金額は`msg.value`で利用可能)、 ```solidity uint amountTokenMin, @@ -1120,23 +1133,23 @@ Bの最適量がBの希望量よりも大きい場合、現在のBトークン assert(IWETH(WETH).transfer(pair, amountETH)); ``` -ETHを入金するには、コントラクトはまずそれをWETHにラップし、次にWETHをペアに送金します。 送金が`assert`でラップされていることに注意してください。 つまり、送金が失敗すると、コントラクトの呼び出しも失敗するので、ラッピングが実際に発生しないということです。 +ETHを入金するために、コントラクトはまずそれをWETHにラップし、次にWETHをペアに転送します。 転送が`assert`でラップされていることに注意してください。 これは、転送が失敗した場合、このコントラクト呼び出しも失敗し、したがってラップは実際には行われないことを意味します。 ```solidity liquidity = IUniswapV2Pair(pair).mint(to); - // refund dust eth, if any + // もしあれば、ダストethを返金します if (msg.value > amountETH) TransferHelper.safeTransferETH(msg.sender, msg.value - amountETH); } ``` -ユーザーは、ETHをすでに送金しているので、(一方のトークンがユーザーが考えるより価値が低いため) 余りが出てしまう場合は、払い戻しを行う必要があります。 +ユーザーはすでにETHを送信しているので、余分なETHが残っている場合(他のトークンがユーザーが考えたよりも価値が低いため)、返金を発行する必要があります。 #### 流動性の削除 {#remove-liquidity} -これらの関数は流動性を削除し、流動性プロバイダーに返却します。 +これらの関数は流動性を削除し、流動性プロバイダーに返金します。 ```solidity - // **** REMOVE LIQUIDITY **** + // **** 流動性の削除 **** function removeLiquidity( address tokenA, address tokenB, @@ -1148,27 +1161,27 @@ ETHを入金するには、コントラクトはまずそれをWETHにラップ ) public virtual override ensure(deadline) returns (uint amountA, uint amountB) { ``` -これは、流動性を削除する最もシンプルなケースです。 各トークンには、流動性プロバイダーが受け入れに同意する最低量があり、期限までに行う必要があります。 +流動性を削除する最も単純なケースです。 各トークンには、流動性プロバイダーが受け入れに同意する最低量があり、それは期限までに行う必要があります。 ```solidity address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB); - IUniswapV2Pair(pair).transferFrom(msg.sender, pair, liquidity); // send liquidity to pair + IUniswapV2Pair(pair).transferFrom(msg.sender, pair, liquidity); // 流動性をペアに送る (uint amount0, uint amount1) = IUniswapV2Pair(pair).burn(to); ``` -コアコントラクトの`burn`関数は、ユーザーへトークンを返却する処理をします。 +コアコントラクトの`burn`関数は、ユーザーにトークンを返却する処理をします。 ```solidity (address token0,) = UniswapV2Library.sortTokens(tokenA, tokenB); ``` -関数が複数の値を返した時、私たちが必要なのはその一部なので、必要な値のみを取得する方法はこうなります。 値を読み取ってそれをまったく使用しないよりも、ガス代を抑えることができます。 +関数が複数の値を返すが、そのうちのいくつかだけに興味がある場合、このようにしてそれらの値だけを取得します。 値を読み取ってまったく使用しないよりも、ガス代の面で多少安くなります。 ```solidity (amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0); ``` -コアコントラクトが返す量(下位アドレスのトークンが最初)から (`tokenA`と`tokenB`に応じて)ユーザが期待する量に置き換えます。 +金額をコアコントラクトが返す方法(アドレスの小さいトークンが先)から、ユーザーが期待する方法(`tokenA`と`tokenB`に対応)に変換します。 ```solidity require(amountA >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT'); @@ -1176,7 +1189,7 @@ ETHを入金するには、コントラクトはまずそれをWETHにラップ } ``` -最初に送金して、その正当性を確認することは問題ありません。正当でなければ、すべての状態変更は元に戻されるからです。 +最初に転送してから正当性を検証することは問題ありません。なぜなら、正当でなければ、すべての状態変更は元に戻されるからです。 ```solidity function removeLiquidityETH( @@ -1202,7 +1215,7 @@ ETHを入金するには、コントラクトはまずそれをWETHにラップ } ``` -WETHトークンを受け取り、ETHと交換して流動性プロバイダーに戻す点を除いて、ETHの流動性を削除する方法はほぼ同じです。 +ETHの流動性を削除する方法はほぼ同じですが、WETHトークンを受け取り、それをETHに換金して流動性プロバイダーに返す点が異なります。 ```solidity function removeLiquidityWithPermit( @@ -1238,11 +1251,11 @@ WETHトークンを受け取り、ETHと交換して流動性プロバイダー } ``` -これらの関数はメタトランザクションをリレーし、[許可メカニズム](#UniswapV2ERC20)を使用して、イーサ(ETH)を持たないユーザーがプールから引き出せるようにします。 +これらの関数はメタトランザクションを中継し、イーサを持たないユーザーが[許可メカニズム](#UniswapV2ERC20)を使用してプールから引き出すことを可能にします。 ```solidity - // **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens) **** + // **** 流動性の削除(送金手数料付きトークンをサポート) **** function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, @@ -1267,7 +1280,7 @@ WETHトークンを受け取り、ETHと交換して流動性プロバイダー ``` -この関数は、送金フィーまたはストレージフィーを持つトークンに使用できます。 トークンに当該フィーがある場合、 `removeLiquidity`関数では、返金されるトークンの量を把握することができないため、最初に引き出してから残高を取得する必要があります。 +この関数は、送金手数料やストレージ手数料を持つトークンに使用できます。 トークンにそのような手数料がある場合、`removeLiquidity`関数に頼って返金されるトークンの量を把握することはできないため、最初に引き出してから残高を取得する必要があります。 ```solidity @@ -1306,7 +1319,7 @@ WETHトークンを受け取り、ETHと交換して流動性プロバイダー for (uint i; i < path.length - 1; i++) { ``` -この記事を執筆している時点で、[388,160種のERC-20トークン](https://etherscan.io/tokens)が存在しています。 各トークンのペアごとにペア取引所がある場合、1500億を超えるペア取引所が存在することになります。 現時点では、チェーン全体で、[ERC-20トークンのアカウント数の0.1%しか存在していません](https://etherscan.io/chart/address)。 代わりに、スワップ関数はパスの概念をサポートしています。 トレーダーは、AをBに、BをCに、CをDに交換できるため、A-Dペアを直接交換する必要はありません。 +これを書いている時点では、[388,160のERC-20トークン](https://eth.blockscout.com/tokens)があります。 各トークンのペアごとにペア取引所がある場合、1500億を超えるペア取引所が存在することになります。 チェーン全体では、現時点で[その数のアカウントの0.1%しかありません](https://eth.blockscout.com/stats/accountsGrowth)。 代わりに、スワップ関数はパスの概念をサポートしています。 トレーダーは、AをBに、BをCに、CをDに交換できるため、A-Dペアを直接交換する必要はありません。 これらのマーケットの価格は同期する傾向にあります。同期していないと、裁定取引の機会が生じてしまうからです。 例えば、3つのトークンA、B、Cで、各ペアに1つずつ合計3つのペア取引所があるとします。 @@ -1315,11 +1328,11 @@ WETHトークンを受け取り、ETHと交換して流動性プロバイダー 3. そのトレーダーは、Bトークンを24.695売り、Cトークンを25.305得ます。Bトークン約0.61を利益として保持します。 4. そして、そのトレーダーは、Cトークンを24.695売って、Aトークンを25.305得ます。Cトークンの約0.61を利益として保持します。 そのトレーダーはまた、余分にAトークンを0.61持っています(トレーダーが最終的に得た25.305から、元の投資の24.695を差し引いたもの) 。 -| ステップ | A-B取引所 | B-C取引所 | A-C取引所 | -| ---- | --------------------------- | --------------------------- | --------------------------- | -| 1 | A:1000 B:1050 A/B=1.05 | B:1000 C:1050 B/C=1.05 | A:1050 C:1000 C/A=1.05 | -| 2 | A:1024.695 B:1024.695 A/B=1 | B:1000 C:1050 B/C=1.05 | A:1050 C:1000 C/A=1.05 | -| 3 | A:1024.695 B:1024.695 A/B=1 | B:1024.695 C:1024.695 B/C=1 | A:1050 C:1000 C/A=1.05 | +| ステップ | A-B取引所 | B-C取引所 | A-C取引所 | +| ---- | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | +| 1 | A:1000 B:1050 A/B=1.05 | B:1000 C:1050 B/C=1.05 | A:1050 C:1000 C/A=1.05 | +| 2 | A:1024.695 B:1024.695 A/B=1 | B:1000 C:1050 B/C=1.05 | A:1050 C:1000 C/A=1.05 | +| 3 | A:1024.695 B:1024.695 A/B=1 | B:1024.695 C:1024.695 B/C=1 | A:1050 C:1000 C/A=1.05 | | 4 | A:1024.695 B:1024.695 A/B=1 | B:1024.695 C:1024.695 B/C=1 | A:1024.695 C:1024.695 C/A=1 | ```solidity @@ -1367,9 +1380,9 @@ WETHトークンを受け取り、ETHと交換して流動性プロバイダー このパラメータには、ERC-20コントラクトのアドレスが含まれています。 上記で説明したように、所有しているアセットから希望するアセットを得るために、いくつかのペア取引所を経由しなければならないため、配列になっています。 -Solidityの関数パラメータは、`memory`または`calldata`のいずれかに格納できます。 関数がコントラクトへのエントリポイントである場合、ユーザーによって(トランザクションを使用して)直接別のコントラクトから呼び出されます。 その後、calldataから直接パラメータの値を取ることができます。 上記`_swap`のように、関数が内部で呼び出されている場合、パラメータは`memory`に保存する必要があります。 呼び出されたコントラクトの観点から、 `calldata`は読み取り専用です。 +Solidityの関数パラメータは、memoryまたはcalldataのいずれかに格納できます。 関数がコントラクトへのエントリポイントである場合、ユーザーによって(トランザクションを使用して)直接別のコントラクトから呼び出されます。その後、calldataから直接パラメータの値を取ることができます。 上記_swapのように、関数が内部で呼び出されている場合、パラメータはmemoryに保存する必要があります。 呼び出されたコントラクトの観点から、 calldataは読み取り専用です。 -`uint`や`address`などのスカラー型では、コンパイラがストレージの選択をしますが、より長くてより高価な配列では、使用するストレージタイプを指定します。 +uintやaddressなどのスカラー型では、コンパイラがストレージの選択をしますが、より長くてより高価な配列では、使用するストレージタイプを指定します。 ```solidity address to, @@ -1394,7 +1407,7 @@ Solidityの関数パラメータは、`memory`または`calldata`のいずれか } ``` -最後に、開始時のERC-20トークンを最初のペア取引所のアカウントに送金し、`_swap`を呼び出します。 これは、すべて同じトランザクション内で発生しているため、ペア取引所は予期しないトークンがこの送金の一部にあることを認識しています。 +最後に、開始時のERC-20トークンを最初のペア取引所のアカウントに送金し、_swapを呼び出します。 これは、すべて同じトランザクション内で発生しているため、ペア取引所は予期しないトークンがこの送金の一部にあることを認識しています。 ```solidity function swapTokensForExactTokens( @@ -1413,7 +1426,7 @@ Solidityの関数パラメータは、`memory`または`calldata`のいずれか } ``` -前にある関数`swapTokensForTokens`では、トレーダーが与える入力トークンの正確な数と、トレーダーが受け取りたい出力トークンの最小数を指定することができます。 この関数では、リバーススワップを行います。トレーダーが希望する出力トークンの数と、支払いを希望する入力トークンの最大数を指定できます。 +前の関数`swapTokensForTokens`では、トレーダーは渡す入力トークンの正確な数と、見返りに受け取りたい出力トークンの最小数を指定できます。 この関数では、リバーススワップを行います。トレーダーが希望する出力トークンの数と、支払いを希望する入力トークンの最大数を指定できます。 どちらの場合も、トレーダーは最初に、このペリフェリーコントラクトに送金できるようにアローワンスを与えなければなりません。 @@ -1501,7 +1514,7 @@ Solidityの関数パラメータは、`memory`または`calldata`のいずれか function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) internal virtual { ``` -これは、送金フィーやストレージフィーがあるトークンをスワップするための内部関数です(詳細は、[問題点(issue)](https://github.com/Uniswap/uniswap-interface/issues/835)をご覧ください) 。 +これは、送金フィーやストレージフィーがあるトークンをスワップするための内部関数です(問題点(issue)をご覧ください) 。 ```solidity for (uint i; i < path.length - 1; i++) { @@ -1517,7 +1530,7 @@ Solidityの関数パラメータは、`memory`または`calldata`のいずれか amountOutput = UniswapV2Library.getAmountOut(amountInput, reserveInput, reserveOutput); ``` -送金フィーがあるため、 各送金で得られるトークン量を知らせてくれる`getAmountsOut`関数に依存することができません(元の`_swap`を呼び出す前に行う方法) 。 代わりに、最初に送金し、戻ったトークンの数を確認する必要があります。 +送金フィーがあるため、`getAmountsOut`関数に依存して各送金で得られるトークン量を知ることはできません(元の`_swap`を呼び出す前に行う方法)。 代わりに、最初に送金し、戻ったトークンの数を確認する必要があります。 注: 理論的には、`_swap`の代わりにこの関数を使うことができますが、特定のケースにおいては、ガス代が高くつくことになります(例えば、 必要最低量に満たないため、最終的に送金処理が元に戻された場合) 。 送金フィートークンは極めてレアなため、受け入れる必要はありますが、少なくとも1つのスワップを経由すると仮定した場合、すべてのスワップで受け入れる必要はありません。 @@ -1648,7 +1661,7 @@ Solidityの関数パラメータは、`memory`または`calldata`のいずれか } ``` -これらの関数は、[UniswapV2ライブラリ関数](#uniswapV2library)を呼び出すプロキシにすぎません。 +これらの関数は、[UniswapV2Library関数](#uniswapV2library)を呼び出す単なるプロキシです。 ### UniswapV2Migrator.sol {#UniswapV2Migrator} @@ -1656,9 +1669,9 @@ Solidityの関数パラメータは、`memory`または`calldata`のいずれか ## ライブラリ {#libraries} -[SafeMathライブラリ](https://docs.openzeppelin.com/contracts/2.x/api/math)は、十分にドキュメント化されているため、ここでドキュメント化する必要はありません。 +[SafeMathライブラリ](https://docs.openzeppelin.com/contracts/2.x/api/math)は十分に文書化されているため、ここで文書化する必要はありません。 -### 数学 {#Math} +### Math {#Math} このライブラリには、Solidityコードで通常は必要としない、言語に含まれていない数学関数があります。 @@ -1687,7 +1700,7 @@ library Math { x = (y / x + x) / 2; ``` -前回の推定値とその平方根を求めようとしている数の平均値を、前回の推定値で割って、より正確な推定値を求めます。 新しい推定値が既存の推定値より低くなくなるまで繰り返します。 詳細については、[こちら](https://wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)をご覧ください。 +前回の推定値とその平方根を求めようとしている数の平均値を、前回の推定値で割って、より正確な推定値を求めます。 新しい推定値が既存の推定値より低くなくなるまで繰り返します。 詳細については、[こちら](https://wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)を参照してください。 ```solidity } @@ -1705,7 +1718,7 @@ library Math { ### 固定点小数(UQ112x112) {#FixedPoint} -このライブラリは、通常イーサリアムの算術の一部ではない小数を処理します。 数字_x_を_x\*2^112_としてコード化して実行することで、 元の加算および減算オペコードをそのまま使用できます。 +このライブラリは、通常イーサリアムの算術の一部ではない小数を処理します。 これは、数値 _x_ を _x\*2^112_ としてエンコードすることで行います。 元の加算および減算オペコードをそのまま使用できます。 ```solidity pragma solidity =0.5.16; @@ -1719,7 +1732,7 @@ library UQ112x112 { uint224 constant Q112 = 2**112; ``` -`Q112`は、コード化の1つです。 +`Q112` は1のエンコーディングです。 ```solidity // encode a uint112 as a UQ112x112 @@ -1728,7 +1741,7 @@ library UQ112x112 { } ``` -yは、`uint112`であるため、大体の値は2^112-1です。 この数字は、`UQ112x112`としてコード化することができます。 +yは`uint112`であるため、最大値は2^112-1です。 その数値は、依然として`UQ112x112`としてエンコードできます。 ```solidity // divide a UQ112x112 by a uint112, returning a UQ112x112 @@ -1740,7 +1753,7 @@ yは、`uint112`であるため、大体の値は2^112-1です。 この数字 2つの`UQ112x112`の値を割ると、結果は2^112で乗算されなくなります。 そのため、代わりに分母に整数を使用します。 乗算を行うには同様のトリックを使用する必要がありますが、`UQ112x112`の値の乗算を行う必要はありません。 -### UniswapV2ライブラリ {#uniswapV2library} +### UniswapV2Library {#uniswapV2library} このライブラリは、ペリフェリーコントラクトにのみ使用されます。 @@ -1762,7 +1775,7 @@ library UniswapV2Library { } ``` -2つのトークンをアドレス順に並び替えて、それらのペア取引所のアドレスを取得できるようにします。 これをしないと、パラメーターA、Bの場合とパラメーターB、Aの場合の2つの可能性が生じ、1つではなく、2つの交換になってしまうため、必ず行ってください。 +2つのトークンをアドレス順に並び替えて、それらのペア取引所のアドレスを取得できるようにします。 これが必要なのは、そうでなければパラメータA、Bの場合とパラメータB、Aの場合の2つの可能性が生じ、1つの取引所ではなく2つの取引所になってしまうからです。 ```solidity // calculates the CREATE2 address for a pair without making any external calls @@ -1777,7 +1790,7 @@ library UniswapV2Library { } ``` -この関数は、2つのトークンのペア取引所のアドレスを計算します。 このコントラクトは、[CREATE2オペコード](https://eips.ethereum.org/EIPS/eip-1014)を使用して作成されるため、使用するパラメータがわかっていれば同じアルゴリズムを使用してアドレスを計算できます。 これはファクトリーよりも大幅に安くなります。 +この関数は、2つのトークンのペア取引所のアドレスを計算します。 このコントラクトは、CREATE2オペコードを使用して作成されるため、使用するパラメータがわかっていれば同じアルゴリズムを使用してアドレスを計算できます。 これはファクトリーに問い合わせるよりもはるかに安価であり、 ```solidity // fetches and sorts the reserves for a pair @@ -1862,9 +1875,9 @@ Solidityは小数をネイティブに扱うことができないため、単に これらの2つの関数は、複数のペア取引所を経由する必要がある場合に、値を特定します。 -### 送金ヘルパー {#transfer-helper} +### Transfer Helper {#transfer-helper} -この[ライブラリ](https://github.com/Uniswap/uniswap-lib/blob/master/contracts/libraries/TransferHelper.sol)は、元の状態に戻せるよう、ERC-20およびイーサリアム送金関連の成功チェックを追加し、同様の方法で`false`値も返します。 +[このライブラリ](https://github.com/Uniswap/uniswap-lib/blob/master/contracts/libraries/TransferHelper.sol)は、ERC-20およびイーサリアムの送金に成功チェックを追加し、リバートと`false`値の戻りを同じように扱います。 ```solidity // SPDX-License-Identifier: GPL-3.0-or-later @@ -1886,7 +1899,7 @@ library TransferHelper { 次の2つの方法のいずれかで異なるコントラクトを呼び出すことができます。 - インターフェイス定義を使い、関数呼び出しを作成。 -- [アプリケーションバイナリインターフェース (ABI)](https://docs.soliditylang.org/en/v0.8.3/abi-spec.html)を使って「手動」で呼び出しを作成。 これは、コードの作成者が行います。 +- [アプリケーションバイナリインターフェイス(ABI)](https://docs.soliditylang.org/en/v0.8.3/abi-spec.html)を「手動で」使用して呼び出しを作成します。 これは、コードの作成者が行います。 ```solidity require( @@ -1896,7 +1909,7 @@ library TransferHelper { } ``` -ERC-20標準以前に作成されたトークンとの後方互換性の便宜上、ERC-20の呼び出しは次のいずれかによって失敗することがあります。1つ目は、(`success`が`false`である場合) 元に戻すことによる失敗、2つ目は、(出力データがあり、それをブール値としてデコードすると`false`になる場合) 成功したうえで`false`値を返すことによる失敗です。 +ERC-20標準以前に作成されたトークンとの後方互換性の便宜上、ERC-20の呼び出しは次のいずれかによって失敗することがあります。1つ目は、(`success`が`false`である場合)元に戻すことによる失敗、2つ目は、(出力データがあり、それをブール値としてデコードすると`false`になる場合)成功したうえで`false`値を返すことによる失敗です。 ```solidity @@ -1915,7 +1928,7 @@ ERC-20標準以前に作成されたトークンとの後方互換性の便宜 } ``` -この関数は、[ERC-20の送金機能](https://eips.ethereum.org/EIPS/eip-20#transfer)を実装しており、あるアカウントが別のアカウントから提供されたアローワンスを使うことができます。 +この関数は、ERC-20の送金機能を実装しており、あるアカウントが別のアカウントから提供されたアローワンスを使うことができます。 ```solidity @@ -1934,7 +1947,7 @@ ERC-20標準以前に作成されたトークンとの後方互換性の便宜 } ``` -この関数は、[ERC-20のtransferFrom機能](https://eips.ethereum.org/EIPS/eip-20#transferfrom)を実装しており、あるアカウントが別のアカウントから提供されたアローワンスを使うことができます。 +この関数は、ERC-20のtransferFrom機能を実装しており、あるアカウントが別のアカウントから提供されたアローワンスを使うことができます。 ```solidity @@ -1947,8 +1960,10 @@ ERC-20標準以前に作成されたトークンとの後方互換性の便宜 この関数は、アカウントにイーサ(ETH)を送金します。 異なるコントラクトへのすべての呼び出しで、イーサ(ETH)の送信ができます。 実際には関数を呼び出す必要がないため、この呼び出しでデータを送信することはありません。 -## まとめ {#conclusion} +## 結論 {#conclusion} この記事は、約50ページにおよびます。 ここまで読んでいただきありがとうございました。 (短いサンプルプログラムとは対照的に)実際のアプリケーションを作成する際の考慮事項を理解し、独自のユースケースにおいてコントラクトを作成できるようになったことを願っています。 ぜひ有用なコードを書いていただき、私たちを驚かせてください。 + +[私の他の作品はこちらでご覧いただけます](https://cryptodocguy.pro/). diff --git a/public/content/translations/ja/developers/tutorials/using-websockets/index.md b/public/content/translations/ja/developers/tutorials/using-websockets/index.md index fb7f8888c49..6288649e052 100644 --- a/public/content/translations/ja/developers/tutorials/using-websockets/index.md +++ b/public/content/translations/ja/developers/tutorials/using-websockets/index.md @@ -1,16 +1,12 @@ --- -title: WebSocketを利用する -description: WebSocketsとAlchemyを使って、JSON-RPCリクエストを作成し、イベントを講読するためのガイド +title: "WebSocketを利用する" +description: "WebSocketsとAlchemyを使って、JSON-RPCリクエストを作成し、イベントを講読するためのガイド" author: "Elan Halpern" lang: ja -tags: - - "Alchemy" - - "WebSockets" - - "クエリ" - - "JavaScript" +tags: ["alchemy", "websockets", "querying", "javascript"] skill: beginner -source: Alchemy ドキュメント -sourceUrl: https://docs.alchemyapi.io/guides/using-websockets +source: Alchemy docs +sourceUrl: https://www.alchemy.com/docs/reference/best-practices-for-using-websockets-in-web3 published: 2020-12-01 --- @@ -22,13 +18,13 @@ HTTPとは異なり、WebSocketでは特定の情報が必要な場合にリク どのネットワーク接続でも同様ですが、WebSocketが中断なしに永続的にオープンであると想定すべきではありませんが、手動で切断された接続に適切に対処し、再接続するのは手間がかかる場合があります。 WebSocketのもう一つの欠点は、応答にはエラーメッセージのみが含まれ、HTTPステータスコードを取得できないという点です。 -[Alchemy Web3](https://docs.alchemy.com/reference/api-overview)を利用することで、WebSocketの接続失敗に自動的に対応し、設定なしでリトライさせることができます。 +[Alchemy Web3](https://docs.alchemy.com/reference/api-overview)は、WebSocketの障害と再試行の処理を、設定不要で自動的に追加します。 -## さっそく試してましょう {#try-it-out} +## 試してみる {#try-it-out} -WebSocketをテストする最も簡単な方法は、[wscat](https://github.com/websockets/wscat)などのWebSocketリクエストを行うためのコマンドラインツールをインストールすることです。 wscatを使って、次のようにリクエストを送ります: +WebSocketをテストする最も簡単な方法は、[wscat](https://github.com/websockets/wscat)のようなWebSocketリクエストを行うためのコマンドラインツールをインストールすることです。 wscatを使って、次のようにリクエストを送ります: -_注意:Alchemyアカウントをお持ちの場合は、 `demo`をあなたのAPIキーに置き換えてください。 [こちら](https://auth.alchemyapi.io/signup)で、Alchemyの無料アカウントを作成できます。_ +_注:Alchemyアカウントをお持ちの場合は、`demo`をご自身のAPIキーに置き換えることができます。 [こちらで無料のAlchemyアカウントにサインアップしてください!](https://auth.alchemy.com/signup)_ ``` wscat -c wss://eth-mainnet.ws.alchemyapi.io/ws/demo @@ -41,13 +37,13 @@ wscat -c wss://eth-mainnet.ws.alchemyapi.io/ws/demo ## WebSocketの使用方法 {#how-to-use-websockets} -まず、アプリにWebSocketのURLを入力してWebSocketを開きます。 アプリのWebSocket URLを確認するには、[ダッシュボード](https://dashboard.alchemyapi.io/)のAppページを開き、「View Key」をクリックしてください。 アプリのWebSocket用URLはHTTPリクエスト用のURLとは異なっており、両方とも「View Key」で確認できる点に注意してください。 +まず、アプリにWebSocketのURLを入力してWebSocketを開きます。 アプリのWebSocket URLは、[ダッシュボード](https://dashboard.alchemy.com/)でアプリのページを開き、「View Key」をクリックして確認できます。 アプリのWebSocket用URLはHTTPリクエスト用のURLとは異なっており、両方とも「View Key」で確認できる点に注意してください。 - + -[Alchemy APIレファレンス](https://docs.alchemyapi.io/documentation/alchemy-api-reference/)に記載されているAPIは、いずれもWebSocket経由で使用可能です。 これには、HTTP POSTリクエストの本文として送信する場合と同じペイロードを使用しますが、このペイロードをWebSocket経由で送信します。 +[Alchemy APIリファレンス](https://www.alchemy.com/docs/reference/api-overview)に記載されているAPIはすべて、WebSocket経由で使用できます。 これには、HTTP POSTリクエストの本文として送信する場合と同じペイロードを使用しますが、このペイロードをWebSocket経由で送信します。 -## Web3でのWebSocket使用方法 {#with-web3} +## Web3を使用 {#with-web3} Web3のようなクライアント向けライブラリを使用する場合、WebSocketへの移行は簡単です。 Web3クライアントのインスタンスを作成する際に、HTTP URLではなくWebSocket URLを渡すだけでよいです。 以下の例をご覧ください: @@ -57,40 +53,40 @@ const web3 = new Web3("wss://eth-mainnet.ws.alchemyapi.io/ws/your-api-key") web3.eth.getBlockNumber().then(console.log) // -> 7946893 ``` -## APIを講読する {#subscription-api} +## サブスクリプションAPI {#subscription-api} -WebSocket経由で接続する場合、`eth_subscribe`および`eth_unsubscribe`という2つの追加メソッドを使用できます。 これらのメソッドを使用することで、特定のイベントをリッスンし、すぐに通知を受け取ることができるようになります。 +WebSocket経由で接続する場合、`eth_subscribe`と`eth_unsubscribe`の2つの追加メソッドを使用できます。 これらのメソッドを使用することで、特定のイベントをリッスンし、すぐに通知を受け取ることができるようになります。 ### `eth_subscribe` {#eth-subscribe} -特定のイベントを対象とする新規のサブスクリプションを作成しましょう。 `eth_subscribe`の詳細については、[こちら](https://docs.alchemy.com/reference/eth-subscribe)をご覧ください。 +特定のイベントを対象とする新規のサブスクリプションを作成しましょう。 [`eth_subscribe`の詳細はこちら](https://docs.alchemy.com/reference/eth-subscribe)。 #### パラメータ {#parameters} -1. サブスクリプションの種類 +1. サブスクリプションのタイプ 2. オプションのパラメータ 最初の引数では、リッスンするイベントのタイプを指定します。 2番目の引数では、最初の引数に依存したオプションを追加します。 以下では、説明タイプ、タイプ別のオプション、およびイベントのペイロードについて説明します。 #### 戻り値 {#returns} -サブスクリプションID:このIDは、受信したすべてのイベントに付与されるもので、`eth_unsubscribe`を使用してサブスクリプションを取り消すする際にも使用します。 +サブスクリプションID:このIDは、受信したすべてのイベントに添付され、`eth_unsubscribe`を使用してサブスクリプションをキャンセルするためにも使用できます。 -#### サブスクリプション関連のイベント {#subscription-events} +#### サブスクリプションイベント {#subscription-events} サブスクリプションが有効である場合、以下のフィールドを含むオブジェクトであるイベントが送信されます: -- `jsonrpc`: 常に「2.0」です。 -- `method`: 常に「eth_subscription」です。 -- `params`:以下のフィールドを含むオブジェクトです: - - `subscription`:このサブスクリプションを作成した`eth_subscribe`の呼び出しが返したサブスクリプションIDです。 - - `result`:サブスクリプションのタイプによって内容が異なるオブジェクトです。 +- `jsonrpc`: 常に「2.0」 +- `method`: 常に「eth_subscription」 +- `params`: 以下のフィールドを持つオブジェクト: + - `subscription`: このサブスクリプションを作成した`eth_subscribe`呼び出しによって返されるサブスクリプションID。 + - `result`: サブスクリプションの種類によって内容が異なるオブジェクト。 -#### サブスクリプションのタイプ {#subscription-types} +#### サブスクリプションの種類 {#subscription-types} 1. `alchemy_newFullPendingTransactions` -保留状態に追加されたすべてのトランザクションにつき、トランザクション情報を返します。 このサブスクリプションタイプは保留中のトランザクションを講読するため、Web3の標準的な呼び出しである`web3.eth.subscribe("pendingTransactions")`と似ていますが、トランザクションのハッシュだけでなく_トランザクションの完全な情報_を発行するという点が異なります。 +保留状態に追加されたすべてのトランザクションにつき、トランザクション情報を返します。 このサブスクリプションタイプは、標準のWeb3呼び出し`web3.eth.subscribe(\"pendingTransactions\")`と同様に保留中のトランザクションをサブスクライブしますが、トランザクションハッシュだけでなく_完全なトランザクション情報_を発行する点で異なります。 例: @@ -160,28 +156,28 @@ WebSocket経由で接続する場合、`eth_subscribe`および`eth_unsubscribe` ``` -3. `ログ類` +3. `logs` 新たに追加されたブロックのうち、指定したフィルター条件に合致した部分のログを発行します。 -チェーンの再構成が発生した場合、`removed`のプロパティを`true`に設定すれば、古いチェーン上のブロックに含まれたログも再度発行されます。 さらに新しいチェーン上のブロックに含まれるログも発行されるため、再編成時には、同一のトランザクションのログが複数回表示される場合があります。 +チェーンの再編成が発生した場合、古いチェーンのブロックの一部であるログは、`removed`プロパティが`true`に設定されて再度発行されます。 さらに新しいチェーン上のブロックに含まれるログも発行されるため、再編成時には、同一のトランザクションのログが複数回表示される場合があります。 パラメータ 1. 以下のフィールドを持つオブジェクトです: - - `address`(オプション):アドレスを表す文字列あるいは、そのような文字列の配列です。 + - `address` (オプション):アドレスを表す文字列、またはそのような文字列の配列のいずれか。 - これらのアドレスのいずれかで作成したログのみが発行されます。 - - `topics`:トピック指定子の配列です。 - - トピック指定子は、`null`、トピックを表す文字列、または文字列の配列のいずれかです。 - - 配列において`null`ではない各位置は、当該の位置において与えられたトピックのひとつを持つユーザーだけにログを発行します。 + - `topics`: トピック指定子の配列。 + - 各トピック指定子は、`null`、トピックを表す文字列、または文字列の配列のいずれかです。 + - `null`でない配列内の各位置は、発行されるログを、その位置に指定されたトピックのいずれかを持つもののみに制限します。 トピック仕様の例: -- `[]`:すべてのトピックを許可します。 -- `[A]`:最初の位置がAである(その後の位置については条件なし)。 -- `[null, B]`:最初の位置は条件なしで、かつ2番目の位置がBである(その後の位置については条件なし)。 -- `[A, B]`:最初の位置がAであり、2番目の位置がB (その後の位置については条件なし) 。 -- `[[A, B], [A, B]]`: 最初の位置が (AまたはB)、かつ2番目の位置が (AまたはB) (その後の位置については条件なし) +- `[]`: すべてのトピックが許可されます。 +- `[A]`: 最初の位置にA (以降は任意)。 +- `[null, B]`: 最初の位置は任意、2番目の位置にB (以降は任意)。 +- `[A, B]`: 最初の位置にA、2番目の位置にB (以降は任意)。 +- `[[A, B], [A, B]]`: 最初の位置に(AまたはB)、2番目の位置に(AまたはB) (以降は任意)。 例: @@ -215,11 +211,11 @@ WebSocket経由で接続する場合、`eth_subscribe`および`eth_unsubscribe` パラメータ -1. 以前に`eth_subscribe`呼び出しで返されたサブスクリプションのIDです。 +1. 以前に`eth_subscribe`呼び出しから返されたサブスクリプションID。 戻り値 -サブスクリプションのキャンセルに成功した場合に`true`、または渡されたIDのサブスクリプションが存在しない場合に`false`が返ります。 +サブスクリプションのキャンセルに成功した場合は`true`、指定されたIDを持つサブスクリプションが存在しなかった場合は`false`。 例: @@ -246,4 +242,4 @@ curl https://eth-mainnet.alchemyapi.io/v2/your-api-key --- -無料で[Alchemyに登録し](https://auth.alchemyapi.io/signup)、[ドキュメント](https://docs.alchemyapi.io/)を確認しましょう。また[Twitter](https://twitter.com/AlchemyPlatform)をフォローして最新のニュースをチェックしてください。 +[Alchemyに無料でサインアップ](https://auth.alchemy.com)し、[ドキュメント](https://www.alchemy.com/docs/)をご覧ください。最新のニュースについては、[Twitter](https://x.com/AlchemyPlatform)でフォローしてください。 diff --git a/public/content/translations/ja/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md b/public/content/translations/ja/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md index 998980038d0..1916adf9f29 100644 --- a/public/content/translations/ja/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md +++ b/public/content/translations/ja/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md @@ -1,38 +1,33 @@ --- -title: "Waffleを使った動的モックアップの活用およびコントラクト呼び出しのテスト" -description: 動的モックアップの活用およびコントラクト呼び出しのテストについてのWaffle上級者向けチュートリアル +title: "Waffle: 動的モッキングとコントラクト呼び出しのテスト" +description: "動的モッキングとコントラクト呼び出しのテストのためのWaffle上級チュートリアル" author: "Daniel Izdebski" -tags: - - "Waffle" - - "スマートコントラクト" - - "Solidity" - - "テスト" - - "モックアップ作成" +tags: ["waffle", "smart contracts", "solidity", "testing", "mocking"] skill: intermediate lang: ja published: 2020-11-14 --- -## チュートリアルの内容 {#what-is-this-tutorial-about} +## このチュートリアルについて {#what-is-this-tutorial-about} -このチュートリアルでは、以下について学びます: +このチュートリアルでは、以下の方法を学びます: -- 動的モックアップの使用方法 -- スマートコントラクト間のやりとりをテストする方法 +- 動的モッキングの使用 +- スマートコントラクト間のインタラクションをテストする 前提知識: -- `Solidity`でシンプルなスマートコントラクトを書ける -- `JavaScript`と`TypeScript`が扱える -- 他の`Waffle`のチュートリアルを受講したか、ある程度知識がある +- `Solidity`で簡単なスマートコントラクトを記述する方法をすでに知っている +- `JavaScript`と`TypeScript`に精通している +- 他の`Waffle`チュートリアルを完了したか、`Waffle`についてある程度の知識がある -## 動的モックアップ {#dynamic-mocking} +## 動的モッキング {#dynamic-mocking} -動的モックアップにはどのような利点があるでしょうか? まず、統合テストではなく、単体テストを書くことができるという点が挙げられます。 どういう意味かと言うと、 スマートコントラクトの依存関係について心配する必要がないので、個々のスマートコントラクトを完全に隔離した状態でテストできるのです。 それでは、その方法を具体的に見ていきましょう。 +動的モッキングはなぜ便利なのでしょうか? これにより、統合テストの代わりに単体テストを作成できます。 これは何を意味するのでしょうか。 つまり、スマートコントラクトの依存関係を気にする必要がなく、完全に分離してすべてのテストを行えるということです。 その具体的な方法をご紹介します。 ### **1. プロジェクト** {#1-project} -まずはじめに、シンプルなnode.jsのプロジェクトを作成します。 +始める前に、簡単なnode.jsプロジェクトを準備する必要があります。 ```bash mkdir dynamic-mocking @@ -40,30 +35,30 @@ cd dynamic-mocking mkdir contracts src yarn init -# or if you're using npm +# またはnpmを使用している場合 npm init ``` -次に、mochaとchaiの依存関係をテストするtypescriptを追加します。 +まず、TypeScriptとテストの依存関係であるmochaとchaiを追加しましょう。 ```bash yarn add --dev @types/chai @types/mocha chai mocha ts-node typescript -# or if you're using npm +# またはnpmを使用している場合 npm install @types/chai @types/mocha chai mocha ts-node typescript --save-dev ``` -さらに、`Waffle`と`ethers`も追加します。 +では、`Waffle`と`ethers`を追加しましょう: ```bash yarn add --dev ethereum-waffle ethers -# or if you're using npm +# またはnpmを使用している場合 npm install ethereum-waffle ethers --save-dev ``` -これにより、プロジェクトの構造は次のようになっているはずです: +これで、プロジェクトの構成は以下のようになります: ``` -。 +. ├── contracts ├── package.json └── test @@ -71,9 +66,9 @@ npm install ethereum-waffle ethers --save-dev ### **2. スマートコントラクト** {#2-smart-contract} -動的モックアップを使用するには、依存関係を含むスマートコントラクトが必要です。 こちらで用意してありますので、ご心配なく! +動的モッキングを開始するには、依存関係のあるスマートコントラクトが必要です。 ご心配なく。こちらで用意してあります。 -今回は`Solidity`で書かれたシンプルなスマートコントラクトを使用しますが、このコントラクトの唯一の目的は、私たちがお金持ちであるかを確認することです。 つまり、十分なERC-20トークンを保有しているかどうかを確認するだけのスマートコントラクトです。 このコードを、`./contracts/AmIRichAlready.sol`に追加します。 +これは`Solidity`で書かれた簡単なスマートコントラクトで、唯一の目的は私たちがお金持ちかどうかをチェックすることです。 ERC20トークンを使って、十分なトークンを保有しているかチェックします。 これを`./contracts/AmIRichAlready.sol`に配置してください。 ```solidity pragma solidity ^0.6.2; @@ -97,9 +92,9 @@ contract AmIRichAlready { } ``` -動的モックアップで使用するだけなので、ERC-20全体は必要なく、関数を1つだけ持つIERC-20インターフェイスを使います。 +動的モッキングを使いたいので、ERC20全体は必要ありません。そのため、関数が1つだけのIERC20インターフェースを使用しています。 -さっそく、コントラクトをビルドしましょう! ビルドには、`Waffle`を使用します。 まず、コンパイルのオプションを指定するシンプルな`waffle.json`設定ファイルを作成します。 +では、このコントラクトをビルドしましょう。 そのために`Waffle`を使用します。 まず、コンパイルオプションを指定する簡単な`waffle.json`設定ファイルを作成します。 ```json { @@ -110,17 +105,17 @@ contract AmIRichAlready { } ``` -さて、Waffleでコントラクトをビルドする準備が整いました。 +これでWaffleでコントラクトをビルドする準備ができました: ```bash npx waffle ``` -簡単ですね。 `build/`フォルダ内に、コントラクトとインターフェイスに対応する2つのファイルが現れました。 これらのファイルを使ってテストを行います。 +簡単でしょう? `build/`フォルダに、コントラクトとインターフェースに対応する2つのファイルが作成されました。 これらは後でテストに使用します。 -### **3. テストを実行する** {#3-testing} +### **3. テスト** {#3-testing} -実際にテストするために、`AmIRichAlready.test.ts`という名前のファイルを作成します。 まずはじめに、インポートを可能にしなければなりません。 これは、後ほど必要になります: +実際のテストのために、`AmIRichAlready.test.ts`というファイルを作成しましょう。 まず、インポートを記述します。 これらは後で必要になります: ```typescript import { expect, use } from "chai" @@ -133,34 +128,34 @@ import { } from "ethereum-waffle" ``` -JSの依存関係の他に、ビルドしたコントラクトとインターフェイスをインポートする必要があります: +JSの依存関係とは別に、ビルドしたコントラクトとインターフェースをインポートする必要があります: ```typescript import IERC20 from "../build/IERC20.json" import AmIRichAlready from "../build/AmIRichAlready.json" ``` -Waffleでは、`chai`を使ってテストを実行します。 ただしその前に、Waffleのマッチャーをchaiに追加する必要があります: +Waffleはテストに`chai`を使用します。 ただし、使用する前にWaffleのマッチャーをchai自体に注入する必要があります: ```typescript use(solidity) ``` -各テストの実行前にコントラクトの状態をリセットするため、`beforeEach()`関数を実装する必要があります。 まず、この関数には何が必要かを考えてみましょう。 コントラクトをデプロイするには、ウォレットと、`AmIRichAlready`コントラクトに引数として渡すためのデプロイされたERC-20コントラクトが必要です。 +各テストの前にコントラクトの状態をリセットする`beforeEach()`関数を実装する必要があります。 まず、そこで何が必要になるかを考えてみましょう。 コントラクトをデプロイするには、ウォレットと、`AmIRichAlready`コントラクトの引数として渡すためのデプロイ済みERC20コントラクトの2つが必要です。 -まず、ウォレットを作成します: +まず、ウォレットを作成します: ```typescript const [wallet] = new MockProvider().getWallets() ``` -次に、ERC-20コントラクトをデプロイする必要があります。 今のところ、私たちはインターフェイスしか持っていないので、工夫が必要になります。 ここで、Waffleが助けてくれます。 Waffleには、インターフェイスの_ABI_だけを使用してコントラクトを作成できる、魔法のような`deployMockContract()`関数が含まれているのです。 +次に、ERC20コントラクトをデプロイする必要があります。 ここが難しいところです。インターフェースしかありません。 ここでWaffleが助けになります。 Waffleには、インターフェースのABIのみを使用してコントラクトを作成する、魔法のような`deployMockContract()`関数があります: ```typescript const mockERC20 = await deployMockContract(wallet, IERC20.abi) ``` -ウォレットとデプロイされたERC-20コントラクトの両方が準備できたので、さっそく`AmIRichAlready`コントラクトをデプロイしましょう: +ウォレットとデプロイ済みのERC20の両方を使用して、`AmIRichAlready`コントラクトをデプロイできます: ```typescript const contract = await deployContract(wallet, AmIRichAlready, [ @@ -168,7 +163,7 @@ const contract = await deployContract(wallet, AmIRichAlready, [ ]) ``` -これで、`beforeEach()`関数が作成できました。 現在のところ、 `AmIRichAlready.test.ts`のファイルは以下のようになっているはずです: +以上で、`beforeEach()`関数は完成です。 ここまでの`AmIRichAlready.test.ts`ファイルは以下のようになります: ```typescript import { expect, use } from "chai" @@ -198,37 +193,37 @@ describe("Am I Rich Already", () => { }) ``` -この`AmIRichAlready`コントラクトの最初のテストを書きましょう。 テストの対象は何にすべきだと思いますか? 言うまでもなく、 私たちがお金持ちであるかをチェックするのですね :) +`AmIRichAlready`コントラクトの最初のテストを書きましょう。 テストでは何をすべきだと思いますか? ええ、その通りです! 私たちがお金持ちかどうかをチェックすべきですね :) -でもちょっと待ってください。 今作成したコントラクトでは、どのような値を返すべきかを指定していませんでした。 `balanceOf()`関数のロジックが実装されていないからです。 ここでもWaffleが助けてくれます。 モックアップを作成したコントラクトには、新たに以下のような素敵なコードが付け加えられています: +しかし、少し待ってください。 モックコントラクトは、どの値を返すかどうやって知るのでしょうか? `balanceOf()`関数のロジックを実装していません。 ここでもWaffleが役立ちます。 モックコントラクトには、このような新しい気の利いた機能が追加されました: ```typescript await mockERC20.mock..returns() await mockERC20.mock..withArgs().returns() ``` -これを知っていれば、最初のテストを書くことができます。 +この知識をもとに、ようやく最初のテストを書くことができます: ```typescript -it("returns false if the wallet has less than 1000000 tokens", async () => { +it("ウォレットの保有するトークンが1,000,000未満の場合にfalseを返す", async () => { await mockERC20.mock.balanceOf.returns(utils.parseEther("999999")) expect(await contract.check()).to.be.equal(false) }) ``` -このテストを、構成要素に分解してみましょう: +このテストを分解してみましょう: -1. モックアップのERC-20コントラクトは、常に、999999トークンの残高を返すように設定します。 -2. `contract.check()`メソッドが、`false`を返すか確認します。 +1. モックERC20コントラクトが常に999,999トークンの残高を返すように設定します。 +2. `contract.check()`メソッドが`false`を返すかどうかを確認します。 -ようやく、テストを実行する準備ができました。 +準備ができたので、実行してみましょう。  -テストは実行されましたが・・・改善の余地がありますね。 `balanceOf()`関数は、常に99999を返します。 実際のコントラクトのように、関数が値を返すウォレットを指定するともっとテストらしくなるでしょう。 +テストは動作しますが、しかし... まだ改善の余地があります。 `balanceOf()`関数は常に99999を返します。 実際のコントラクトのように、関数が値を返すウォレットを指定することで改善できます: ```typescript -it("returns false if the wallet has less than 1000001 tokens", async () => { +it("ウォレットの保有するトークンが1,000,001未満の場合にfalseを返す", async () => { await mockERC20.mock.balanceOf .withArgs(wallet.address) .returns(utils.parseEther("999999")) @@ -236,10 +231,10 @@ it("returns false if the wallet has less than 1000001 tokens", async () => { }) ``` -このテストでは、今のところ、私たちが十分にお金持ちではない場合のみをチェックしています。 次に、その反対もチェックできるようにしてみましょう: +ここまでは、十分にお金持ちでない場合のみをテストしました。 代わりに、その逆をテストしてみましょう: ```typescript -it("returns true if the wallet has at least 1000001 tokens", async () => { +it("ウォレットが少なくとも1,000,001トークンを保有している場合にtrueを返す", async () => { await mockERC20.mock.balanceOf .withArgs(wallet.address) .returns(utils.parseEther("1000001")) @@ -247,28 +242,28 @@ it("returns true if the wallet has at least 1000001 tokens", async () => { }) ``` -テストを実行します・・・ +テストを実行すると...  -そして・・・うまく行きました! 私たちのコントラクトは、意図したとおりに動作しているようです :) +...これで完了です! コントラクトは意図通りに動作しているようです :) -## コントラクトの呼び出しをテストする {#testing-contract-calls} +## コントラクト呼び出しのテスト {#testing-contract-calls} -これまでの進展をまとめておきましょう。 `AmIRichAlready`コントラクトの機能をテストし、正常に動作していることが確認できたようです。 これで終わりだろうって? いいえ、まだ少し残っています。 Waffeを使えば、さらに多くの事項をテストすることができます。 具体的に説明すると、 Waffleには`calledOnContract()`マッチャーと`calledOnContractWith()`マッチャーが搭載されています。 これらを使えば、作成したコントラクトがモックアップのERC-20コントラクトを呼び出したかどうかを確認できるのです。 いずれかのマッチャーを使用した基本的なテストは、次のようになります: +これまでの作業をまとめましょう。 `AmIRichAlready`コントラクトの機能をテストし、正しく動作しているようです。 これで完了ということですよね? 必ずしもそうではありません。 Waffleを使えば、コントラクトをさらにテストすることができます。 しかし、具体的にはどうやって? Waffleには、`calledOnContract()`と`calledOnContractWith()`というマッチャーが用意されています。 これらにより、コントラクトがERC20モックコントラクトを呼び出したかどうかをチェックできます。 これらのマッチャーの1つを使用した基本的なテストは次のとおりです: ```typescript -it("checks if contract called balanceOf on the ERC20 token", async () => { +it("コントラクトがERC20トークンでbalanceOfを呼び出したかチェックする", async () => { await mockERC20.mock.balanceOf.returns(utils.parseEther("999999")) await contract.check() expect("balanceOf").to.be.calledOnContract(mockERC20) }) ``` -もう一方のマッチャーを使用することで、さらにこのテストを充実させることができます: +先ほどお話ししたもう一方のマッチャーで、このテストをさらに改善することができます: ```typescript -it("checks if contract called balanceOf with certain wallet on the ERC20 token", async () => { +it("コントラクトがERC20トークンで特定のウォレットに対してbalanceOfを呼び出したかチェックする", async () => { await mockERC20.mock.balanceOf .withArgs(wallet.address) .returns(utils.parseEther("999999")) @@ -277,22 +272,22 @@ it("checks if contract called balanceOf with certain wallet on the ERC20 token", }) ``` -テストがうまく行ったか確認しましょう: +テストが正しいかチェックしましょう:  -幸いなことに、すべてのテストに合格しました。 +素晴らしい、すべてのテストに合格しました。 -Waffleを使えば、コントラクトの呼び出しをとても簡単にテストできます。 特にすばらしいのは、 これらのマッチャーを通常のコントラクトとモックアップのコントラクトの両方に使えることです! 他のテクノロジー向けの人気が高いテストライブラリと同じように、Waffleは、コードを挿入するのではなく、EVM呼び出しを記録し、フィルタ処理を行うアプローチを採用しています。 +Waffleを使ったコントラクト呼び出しのテストは非常に簡単です。 そして、ここからが一番すごいところです。 これらのマッチャーは、通常のコントラクトとモックコントラクトの両方で動作します! これは、他の技術で一般的なテストライブラリのようにコードを注入するのではなく、WaffleがEVM呼び出しを記録・フィルタリングするためです。 -## おわりに {#the-finish-line} +## ゴール {#the-finish-line} -おめでとうございます! これで、Waffleを使用して、コントラクトの呼び出しや、モックアップのコントラクトを動的にテストする方法を身に付けることができました。 この他にもたくさんの興味深い機能がありますので、 Waffleのドキュメンテーションに目を通すことをおすすめします。 +おめでとうございます! これで、Waffleを使ってコントラクト呼び出しをテストし、コントラクトを動的にモックする方法がわかりました。 他にも発見すべき興味深い機能がたくさんあります。 Waffleのドキュメンテーションを深く読んでみることをお勧めします。 -Waffleのドキュメンテーションは、[こちら](https://ethereum-waffle.readthedocs.io/)から入手できます。 +Waffleのドキュメンテーションは[こちら](https://ethereum-waffle.readthedocs.io/)でご覧いただけます。 -このチュートリアルのソースコードは、[こちら](https://github.com/EthWorks/Waffle/tree/master/examples/dynamic-mocking-and-testing-calls)からアクセスできます。 +このチュートリアルのソースコードは[こちら](https://github.com/EthWorks/Waffle/tree/master/examples/dynamic-mocking-and-testing-calls)にあります。 -さらに、以下のチュートリアルをおすすめします: +こちらもおすすめのチュートリアルです: -- [Waffleを使ってスマートコントラクトをテストする](/developers/tutorials/testing-smart-contract-with-waffle/) +- [Waffleでスマートコントラクトをテストする](/developers/tutorials/waffle-test-simple-smart-contract/) diff --git a/public/content/translations/ja/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md b/public/content/translations/ja/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md index aea5d5cf679..d499f75c2e9 100644 --- a/public/content/translations/ja/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md +++ b/public/content/translations/ja/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md @@ -1,46 +1,48 @@ --- title: "WaffleでHardhatとethersを使って「Hello world!」と出力するチュートリアル" -description: Hardhatとethers.jsを使って、はじめてのWaffleプロジェクトを作成する +description: "Hardhatとethers.jsを使って、はじめてのWaffleプロジェクトを作成する" author: "MiZiet" tags: - - "Waffle" - - "スマートコントラクト" - - "Solidity" - - "テスト" - - "Hardhat" - - "ethers.js" + [ + "waffle", + "スマート契約", + "Solidity", + "テスト", + "hardhat", + "ethers.js" + ] skill: beginner lang: ja published: 2020-10-16 --- -この[Waffle](https://ethereum-waffle.readthedocs.io)チュートリアルでは、[Hardhat](https://hardhat.org/)と[ethers.js](https://docs.ethers.io/v5/)を使用して、「Hello world」と表示するシンプルなスマートコントラクトのプロジェクトを作成する方法を学びます。 さらに、Waffle上で作成したスマートコントラクトに新たな機能を追加し、テストする方法を学びます。 +この[Waffle](https://ethereum-waffle.readthedocs.io)チュートリアルでは、[hardhat](https://hardhat.org/)と[ethers.js](https://docs.ethers.io/v5/)を使い、シンプルな「Hello world」スマートコントラクトプロジェクトをセットアップする方法を学びます。 次に、スマートコントラクトに新しい機能を追加する方法と、Waffleでそれをテストする方法を学びます。 -まずはじめに新しいプロジェクトを作成しましょう。 +まず、新しいプロジェクトを作成することから始めましょう: ```bash yarn init ``` -あるいは、 +または ```bash npm init ``` -必要なパッケージをインストールします: +そして、必要なパッケージをインストールします: ```bash yarn add -D hardhat @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai ``` -以下を実行してもよいです: +または ```bash npm install -D hardhat @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai ``` -次に、`npx hardhat`を実行して、サンプルのHardhatプロジェクトを作成します。 +次のステップでは、`npx hardhat`を実行して、Hardhatのサンプルプロジェクトを作成します。 ```bash 888 888 888 888 888 @@ -52,17 +54,17 @@ npm install -D hardhat @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffl 888 888 888 888 888 Y88b 888 888 888 888 888 Y88b. 888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888 -👷 Welcome to Hardhat v2.0.3 👷 +👷 Hardhat v2.0.3へようこそ 👷 -? What do you want to do? … -❯ Create a sample project -Create an empty hardhat.config.js -Quit +? 何をしますか? … +❯ サンプルプロジェクトを作成する +空のhardhat.config.jsを作成する +終了 ``` -`Create a sample project`を選択します。 +「Create a sample project」を選択します -プロジェクトの構造は、以下のようになっているはずです: +プロジェクトの構成は次のようになります: ``` MyWaffleProject @@ -79,9 +81,9 @@ MyWaffleProject └── package.json ``` -### 次に、これらのファイルのいくつかを説明します。 {#now-lets-talk} +### では、これらのファイルについて見ていきましょう: {#now-lets-talk} -- Greeter.solは、このチュートリアルで使用するSolidityで書かれたスマートコントラクトです。 +- Greeter.sol - Solidityで書かれたスマートコントラクトです。 ```solidity contract Greeter { @@ -103,17 +105,17 @@ greeting = _greeting; } ``` -このスマートコントラクトは、以下の3つの要素に分解できます: +このスマートコントラクトは、3つの部分に分けられます: -1. コンストラクタ:`greeting`という名前の文字列型の変数を宣言する場所です。 -2. greet関数:`greeting`を返す関数です。 -3. setGreeting関数:`greeting`の値を変更する関数です。 +1. constructor - `greeting`という名前のstring型変数を宣言します。 +2. function greet - 呼び出されたときに`greeting`を返す関数です。 +3. function setGreeting - `greeting`の値を変更できるようにする関数です。 -- sample-test.js:テストを実行するファイルです。 +- sample-test.js - テストファイルです ```js describe("Greeter", function () { - it("Should return the new greeting once it's changed", async function () { + it("変更されると新しい挨拶を返すはず", async function () { const Greeter = await ethers.getContractFactory("Greeter") const greeter = await Greeter.deploy("Hello, world!") @@ -126,23 +128,23 @@ describe("Greeter", function () { }) ``` -### 次に、コントラクトをコンパイルし、テストを実行します。 {#compiling-and-testing} +### 次のステップでは、コントラクトのコンパイルとテストの実行を行います: {#compiling-and-testing} -Waffleでは、Mocha(テスト用フレームワーク)およびChai(アサーションライブラリ)を使ってテストを実行します。 `npx hardhat test`を実行して、以下のメッセージが表示されるまで待つだけです。 +Waffleのテストでは、Mocha (テストフレームワーク) とChai (アサーションライブラリ) を使用します。 `npx hardhat test`を実行し、次のメッセージが表示されるのを待つだけです。 ```bash -✓ Should return the new greeting once it's changed +✓ 変更されると新しい挨拶を返すはず ``` -### 今のところ順調ですので、プロジェクトにもう少し機能を付け加えてみましょう {#adding-complexity} +### ここまでは順調です。プロジェクトにもう少し複雑な機能を追加してみましょう {#adding-complexity} -他のユーザーが、挨拶の代わりに空の文字列を追加したと想定してみましょう。 無言の挨拶は嬉しくありませんね! -ですから、このようなことが起こらないようにします: +誰かが挨拶として空の文字列を追加する状況を想像してみてください。 それでは心のこもった挨拶にはなりませんよね? +そうならないようにしてみましょう: -空の文字列が渡された場合に、Solidityの`revert`機能を利用できるようにします。 この機能は、Waffleのchaiマッチャーである`to.be.revertedWith()`で簡単にテストできます。 +誰かが空の文字列を渡した場合に、Solidityの`revert`を使いたいと思います。 幸いなことに、WaffleのChaiマッチャー`to.be.revertedWith()`を使えば、この機能を簡単にテストできます。 ```js -it("Should revert when passing an empty string", async () => { +it("空の文字列を渡したときにリバートするはず", async () => { const Greeter = await ethers.getContractFactory("Greeter") const greeter = await Greeter.deploy("Hello, world!") @@ -153,28 +155,28 @@ it("Should revert when passing an empty string", async () => { }) ``` -このテストには、合格しなかったようです。 +新しいテストはパスしなかったようです: ```bash Deploying a Greeter with greeting: Hello, world! Changing greeting from 'Hello, world!' to 'Hola, mundo!' - ✓ Should return the new greeting once it's changed (1514ms) + ✓ 変更されると新しい挨拶を返すはず (1514ms) Deploying a Greeter with greeting: Hello, world! Changing greeting from 'Hello, world!' to '' - 1) Should revert when passing an empty string + 1) 空の文字列を渡したときにリバートするはず - 1 passing (2s) - 1 failing + 1件成功 (2s) + 1件失敗 ``` -さっそくこの機能を、先ほど作成したスマートコントラクトに追加しましょう: +この機能をスマートコントラクトに実装しましょう: ```solidity require(bytes(_greeting).length > 0, "Greeting should not be empty"); ``` -これにより、setGreeting関数は以下のようになっているはずです: +これで、setGreeting関数は次のようになります: ```solidity function setGreeting(string memory _greeting) public { @@ -184,19 +186,19 @@ greeting = _greeting; } ``` -もう一度、テストを実行してみましょう: +もう一度テストを実行してみましょう: ```bash -✓ Should return the new greeting once it's changed (1467ms) -✓ Should revert when passing an empty string (276ms) +✓ 変更されると新しい挨拶を返すはず (1467ms) +✓ 空の文字列を渡したときにリバートするはず (276ms) -2 passing (2s) +2件成功 (2s) ``` -おめでとうございます! テストが完成しました :) +おめでとうございます! やり遂げましたね :) -### まとめ {#conclusion} +### 結論 {#conclusion} -Waffle、Hardhat、およびethers.jsを使った簡単なプロジェクトを作成しました。 このチュートリアルでは、プロジェクトを開始し、テストを追加し、さらに新たな機能を実装する方法について学びました。 +Waffle、Hardhat、ethers.jsを使ってシンプルなプロジェクトを作成しました。 プロジェクトのセットアップ、テストの追加、新機能の実装方法を学びました。 -スマートコントラクトのテストに大活躍するChaiマッチャーについてさらに知りたい場合は、[Waffleの公式文書](https://ethereum-waffle.readthedocs.io/en/latest/matchers.html)を参照してください。 +スマートコントラクトをテストするための、さらに優れたChaiマッチャーについては、[Waffleの公式ドキュメント](https://ethereum-waffle.readthedocs.io/en/latest/matchers.html)を確認してください。 diff --git a/public/content/translations/ja/developers/tutorials/waffle-test-simple-smart-contract/index.md b/public/content/translations/ja/developers/tutorials/waffle-test-simple-smart-contract/index.md index 411b6c6401b..ceb88086950 100644 --- a/public/content/translations/ja/developers/tutorials/waffle-test-simple-smart-contract/index.md +++ b/public/content/translations/ja/developers/tutorials/waffle-test-simple-smart-contract/index.md @@ -1,24 +1,20 @@ --- -title: Waffleライブラリを使用したシンプルなスマートコントラクトのテスト -description: 初心者用チュートリアル +title: "Waffleライブラリを使用したシンプルなスマートコントラクトのテスト" +description: "初心者用チュートリアル" author: Ewa Kowalska -tags: - - "スマートコントラクト" - - "Solidity" - - "Waffle" - - "テスト" +tags: ["smart contracts", "solidity", "waffle", "testing"] skill: beginner lang: ja published: 2021-02-26 --- -## このチュートリアルでは、以下について学びます {#in-this-tutorial-youll-learn-how-to} +## このチュートリアルでは、次の方法を学びます {#in-this-tutorial-youll-learn-how-to} -- ウォレットの残高が変わることのテスト -- 特定の引数でイベントが発行されることのテスト -- トランザクションが取り消されたことのアサーション +- ウォレット残高の変更をテストする +- 指定された引数を持つイベントの発行をテストする +- トランザクションがrevertされたことをアサートする -## 前提知識 {#assumptions} +## 前提条件 {#assumptions} - 新規のJavaScriptまたはTypeScriptのプロジェクトを作成できる - JavaScriptのテストの基本的な経験がある @@ -27,19 +23,20 @@ published: 2021-02-26 ## はじめに {#getting-started} -このチュートリアルでは、yarnを使ってテストのセットアップおよび実行をしていますが、npmの方が良ければnpmでも問題ありません。公式のWaffleのドキュメントは、[こちら](https://ethereum-waffle.readthedocs.io/en/latest/index.html)になります。 +このチュートリアルでは、yarnを使ったテストのセットアップと実行を実演しますが、npmがお好みであれば問題ありません。公式Waffleの[ドキュメント](https://ethereum-waffle.readthedocs.io/en/latest/index.html)への適切なリファレンスを記載します。 -### 依存関係のインストール {#install-dependencies} +## 依存関係をインストール {#install-dependencies} -プロジェクトに対してethereum-waffleとtypescriptの依存関係を開発環境の依存関係に[追加](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#installation)します。 +ethereum-waffleとtypescriptの依存関係をプロジェクトの開発依存関係に[追加](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#installation)します。 ```bash yarn add --dev ethereum-waffle ts-node typescript @types/jest ``` -### スマートコントラクトのコード例 {#example-smart-contract} +## スマートコントラクトの例 {#example-smart-contract} -このチュートリアルでは、EtherSplitterというシンプルなスマートコントラクトの例に取り組みます。 このコードでは、誰もがweiを送信でき、それを2つの事前定義された受信者間で均等に分割するだけです。 split関数ではweiの数が偶数でなければなりません。さもないと処理が取り消されます。 両方の受信者に対して、weiの送金を実行し、続いてTransferイベントを発行します。 +このチュートリアルでは、EtherSplitterというシンプルなスマートコントラクトの例に取り組みます。 誰かがweiを送金し、それを2つの事前定義された受信者の間で均等に分割できるようにする以外に、特別な機能はありません。 +split関数ではweiの数が偶数でなければなりません。さもないと処理は取り消されます。 両方の受信者に対して、weiの送金を実行し、続いてTransferイベントを発行します。 `src/EtherSplitter.sol`に、EtherSplitterコードのスニペットを配置します。 @@ -67,9 +64,9 @@ contract EtherSplitter { } ``` -### コントラクトのコンパイル {#compile-the-contract} +## コントラクトをコンパイルする {#compile-the-contract} -コントラクトを[コンパイル](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#compiling-the-contract)するのに、package.jsonファイルに次のエントリを追加します。 +コントラクトを[コンパイル](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#compiling-the-contract)するには、package.jsonファイルに次のエントリを追加します。 ```json "scripts": { @@ -77,7 +74,7 @@ contract EtherSplitter { } ``` -次に、プロジェクトのルートディレクトリにWaffleの設定ファイル (`waffle.json`) を作成し、次の設定を貼り付けます。 +次に、プロジェクトのルートディレクトリにWaffleの設定ファイル (`waffle.json`) を作成し、次の設定をそこに貼り付けます。 ```json { @@ -88,11 +85,11 @@ contract EtherSplitter { } ``` -`yarn build`を実行してください。 終了すると、`build`ディレクトリに、JSON形式でコンパイルされたEtherSplitterコントラクトが現れます。 +`yarn build` を実行します。 結果として、`build`ディレクトリに、コンパイルされたEtherSplitterコントラクトがJSON形式で現れます。 -### テストの設定 {#test-setup} +## テストのセットアップ {#test-setup} -Waffleでテストするには ChaiマッチャーとMochaが必要になるため、プロジェクトに[追加](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#writing-tests)します。 次のようにscriptの場所に`test`エントリを追加してpackage.jsonファイルを更新してください。 +Waffleを使ったテストにはChaiマッチャーとMochaが必要なので、それらをプロジェクトに[追加](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#writing-tests)する必要があります。 package.jsonファイルを更新し、scriptsの部分に`test`エントリを追加してください。 ```json "scripts": { @@ -101,11 +98,12 @@ Waffleでテストするには ChaiマッチャーとMochaが必要になるた } ``` -テストを[実行](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#running-tests)する場合は、 `yarn test`を実行します。 +テストを[実行](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#running-tests)したい場合は、`yarn test`を実行するだけです。 -## テストを実行する {#testing} +## テスト {#testing} -それでは、`test`ディレクトリを作成し、新しいファイル `test\EtherSplitter.test.ts`を作成してください。 以下のスニペットをコピーして、テストファイルに貼り付けてください。 +それでは、`test`ディレクトリを作成し、新しいファイル `test\EtherSplitter.test.ts`を作成してください。 +以下のスニペットをコピーして、テストファイルに貼り付けてください。 ```ts import { expect, use } from "chai" @@ -115,7 +113,7 @@ import EtherSplitter from "../build/EtherSplitter.json" use(solidity) -describe("Ether Splitter", () => { +describe("イーサスプリッター", () => { const [sender, receiver1, receiver2] = new MockProvider().getWallets() let splitter: Contract @@ -126,20 +124,21 @@ describe("Ether Splitter", () => { ]) }) - // add the tests here + // ここにテストを追加 }) ``` -始める前に、少し解説をします。 `MockProvider`は、ブロックチェーンのモックバージョンを作成します。 また、EtherSplitterコントラクトのテストで役立つモックウォレットも提供します。 このプロバイダーで、`getWallets()`メソッドを呼び出すと最大10個までウォレットを取得することができます。 この例では、3つのウォレットを取得します。1つは、送信者用で、2つは、受信者用です。 +始める前に、少し解説をします。 +`MockProvider`は、ブロックチェーンのモックバージョンを作成します。 また、EtherSplitterコントラクトのテストで役立つモックウォレットも提供します。 このプロバイダーで、`getWallets()`メソッドを呼び出すと最大10個までウォレットを取得することができます。 この例では、送信者用と2人の受信者用の3つのウォレットを取得します。 -次に、「splitter」という変数を宣言します。これは、 EtherSplitterコントラクトのモックです。 このモックは、単一のテストを実行する前に`deployContract`メソッドによって作成されます。 当該のメソッドは、最初のパラメータとして渡されたウォレット (この場合は送信者のウォレット) からコントラクトのデプロイメントをシミュレートします。 2番目のパラメータは、テストされるコントラクトのABIとバイトコードです。コンパイルされたEtherSplitterコントラクトのjsonファイルを`build`ディレクトから渡します。 3番目のパラメータは、コントラクトのコンストラクタ引数を持つ配列です。この場合、受信者の2つのアドレスです。 +次に、「splitter」という変数を宣言します。これは、EtherSplitterコントラクトのモックです。 このモックは、単一のテストを実行する前に`deployContract`メソッドによって作成されます。 当該のメソッドは、最初のパラメータとして渡されたウォレット (この場合は送信者のウォレット) からコントラクトのデプロイメントをシミュレートします。 2番目のパラメータは、テストされるコントラクトのABIとバイトコードです。コンパイルされたEtherSplitterコントラクトのjsonファイルを`build`ディレクトリから渡します。 3番目のパラメータは、コントラクトのコンストラクタ引数を持つ配列です。この場合、2人の受信者のアドレスです。 -### changeBalances {#changebalances} +## changeBalances {#changebalances} -まず、splitメソッドによって実際に受取人のウォレットの残高が変わるかどうかを確認します。 送信者のアカウントから50weiを分割すると、両方の受信者の残高が25wei増えることが期待されます。 ここで、Waffleの`changeBalances`マッチャーを使います。 +まず、splitメソッドによって実際に受取人のウォレットの残高が変わるかどうかを確認します。 送信者のアカウントから50 weiを分割すると、両方の受信者の残高が25 wei増えることが期待されます。 ここで、Waffleの`changeBalances`マッチャーを使います。 ```ts -it("Changes accounts balances", async () => { +it("アカウントの残高を変更する", async () => { await expect(() => splitter.split({ value: 50 })).to.changeBalances( [receiver1, receiver2], [25, 25] @@ -147,10 +146,11 @@ it("Changes accounts balances", async () => { }) ``` -マッチャーの最初のパラメータとして、受信者のウォレットの配列を渡し、2番目のパラメータとして、対応するアカウントで予想される増加分を配列で渡します。 特定のウォレットの残高を確認したい場合は、以下の例のように、配列を渡さなくても`changeBalance`マッチャーを使えます。 +マッチャーの最初のパラメータとして、受信者のウォレットの配列を渡し、2番目のパラメータとして、対応するアカウントで予想される増加分を配列で渡します。 +特定のウォレットの残高を確認したい場合は、以下の例のように、配列を渡さなくても`changeBalance`マッチャーを使えます。 ```ts -it("Changes account balance", async () => { +it("アカウントの残高を変更する", async () => { await expect(() => splitter.split({ value: 50 })).to.changeBalance( receiver1, 25 @@ -158,41 +158,41 @@ it("Changes account balance", async () => { }) ``` -`changeBalance`と `changeBalances`のどちらの場合も、split関数をコールバックとして渡します。マッチャーは呼び出しの前後に残高の状態にアクセスする必要があるためです。 +`changeBalance`と`changeBalances`のどちらの場合も、マッチャーが呼び出しの前後に残高の状態にアクセスする必要があるため、split関数をコールバックとして渡すことに注意してください。 -次では、weiの各転送後にTransferイベントが発行されたかどうかをテストします。 それでは、Waffleの別のマッチャーに移ります。 +次に、weiの各転送後にTransferイベントが発行されたかどうかをテストします。 それでは、Waffleの別のマッチャーに移ります。 -### Emit {#emit} +## Emit {#emit} ```ts -it("Emits event on the transfer to the first receiver", async () => { +it("最初の受信者への転送時にイベントを発行する", async () => { await expect(splitter.split({ value: 50 })) .to.emit(splitter, "Transfer") .withArgs(sender.address, receiver1.address, 25) }) -it("Emits event on the transfer to the second receiver", async () => { +it("2番目の受信者への転送時にイベントを発行する", async () => { await expect(splitter.split({ value: 50 })) .to.emit(splitter, "Transfer") .withArgs(sender.address, receiver2.address, 25) }) ``` -`emit`マッチャーを使うと、メソッドの呼び出し時にコントラクトがイベントを発行したかどうかを確認できます。 `emit`マッチャーへのパラメーターとして、イベントを発行することが予期されるモックコントラクトとそのイベントの名前を渡します。 この場合、モックコントラクトは`splitter`で、イベント名は`Transfer`です。 また、イベントの発行で引数の正確な値を検証することもできます。その場合、イベントの宣言で期待される数の引数を `withArgs`マッチャーに渡します。 EtherSplitterコントラクトの場合では、送金されるwei単位の金額とともに送信者と受信者のアドレスを渡します。 +`emit`マッチャーを使うと、メソッドの呼び出し時にコントラクトがイベントを発行したかどうかを確認できます。 `emit`マッチャーへのパラメータとして、イベントを発行することが予期されるモックコントラクトとそのイベントの名前を渡します。 この場合、モックコントラクトは`splitter`で、イベント名は`Transfer`です。 また、イベントの発行で引数の正確な値を検証することもできます。その場合、イベントの宣言で期待される数の引数を`withArgs`マッチャーに渡します。 EtherSplitterコントラクトの場合では、送金されるwei単位の金額とともに送信者と受信者のアドレスを渡します。 -### revertedWith {#revertedwith} +## revertedWith {#revertedwith} 最後の例として、weiの数が奇数の場合にトランザクションが取り消されるかどうかを確認します。 ここでは、`revertedWith`マッチャーを使います。 ```ts -it("Reverts when Vei amount uneven", async () => { +it("weiの量が奇数の場合にrevertする", async () => { await expect(splitter.split({ value: 51 })).to.be.revertedWith( "Uneven wei amount not allowed" ) }) ``` -このテストをパスすれば、トランザクションが実際に取り消されたことが保証されます。 ただし、`require`ステートメントで渡したメッセージと、`revertedWith`で期待しているメッセージとが完全に一致している必要があります。 EtherSplitterコントラクトのコードに戻った場合、weiの金額の`require`ステートメントで、「偶数でないwei単位の金額は許可されていません」というメッセージが表示されます。 これは、テストで予期されるメッセージと一致します。 それらが等しくなければ、テストは失敗します。 +このテストをパスすれば、トランザクションが実際に取り消されたことが保証されます。 ただし、`require`ステートメントで渡したメッセージと、`revertedWith`で期待しているメッセージとが完全に一致している必要があります。 EtherSplitterコントラクトのコードに戻ると、weiの量に対する`require`ステートメントで、「Uneven wei amount not allowed」というメッセージが表示されます。 これは、テストで予期されるメッセージと一致します。 それらが等しくなければ、テストは失敗します。 ## おめでとうございます! {#congratulations} diff --git a/public/content/translations/ja/developers/tutorials/yellow-paper-evm/index.md b/public/content/translations/ja/developers/tutorials/yellow-paper-evm/index.md index b715247d540..153b8301743 100644 --- a/public/content/translations/ja/developers/tutorials/yellow-paper-evm/index.md +++ b/public/content/translations/ja/developers/tutorials/yellow-paper-evm/index.md @@ -1,9 +1,8 @@ --- -title: イエローペーパーにおけるEVM仕様の理解 -description: イーサリアムの正式な仕様であるイエローペーパーでのイーサリアム仮想マシン(EVM)についての説明を理解する。 +title: "イエローペーパーにおけるEVM仕様の理解" +description: "イーサリアムの正式な仕様であるイエローペーパーでのイーサリアム仮想マシン(EVM)についての説明を理解する。" author: "qbzzt" -tags: - - "イーサリアム仮想マシン(EVM)" +tags: ["evm"] skill: intermediate lang: ja published: 2022-05-15 @@ -13,252 +12,267 @@ published: 2022-05-15 ## 解説するイエローペーパーについて {#which-yellow-paper} -イーサリアムに関する他のものと同じように、イエローペーパーも時間の経過とともに進化しています。 特定のバージョンを参照できるように、[執筆時のバージョン](yellow-paper-berlin.pdf)をアップロードしています。 このドキュメントで使用するセクション番号、ページ番号、数式番号は、そのバージョンを参照しています。 ドキュメントを読む際は、アップロードされたイエローペーパーを別のウィンドウで開いておくと便利です。 +イーサリアムに関する他のものと同じように、イエローペーパーも時間の経過とともに進化しています。 特定のバージョンを参照できるように、[執筆時の現行バージョン](yellow-paper-berlin.pdf)をアップロードしました。 このドキュメントで使用するセクション番号、ページ番号、数式番号は、そのバージョンを参照しています。 このドキュメントを読む際は、別のウィンドウで開いておくことをお勧めします。 -### EVMを解説する理由 {#why-the-evm} +### なぜEVMなのか? {#why-the-evm} -イーサリアムの開発が始まったときに書かれたオリジナルのイエローペーパーでは、 コンセンサスメカニズムのベースとなったオリジナルのプルーフ・オブ・ワークについて記述されていました。 しかし、イーサリアムでは、2022年9月にプルーフ・オブ・ワークを止め、プルーフ・オブ・ステークをベースとしたコンセンサスを使い始めました。 このチュートリアルでは、イエローペーパーにおけるイーサリアム仮想マシンの定義部について解説します。 プルーフ・オブ・ステークへの移行後も、EVMは変更されていないことが解説する理由です。ただし、DIFFICULTY オペコードの戻り値は変更されています。 +オリジナルのイエローペーパーは、イーサリアムの開発が始まった直後に書かれました。 そこには、ネットワークのセキュリティを確保するために当初使用されていた、プルーフ・オブ・ワークベースの独自のコンセンサスメカニズムが記述されています。 しかし、イーサリアムは2022年9月にプルーフ・オブ・ワークを停止し、プルーフ・オブ・ステークベースのコンセンサスを使用し始めました。 このチュートリアルでは、イーサリアム仮想マシンを定義するイエローペーパーの部分に焦点を当てます。 EVMは、プルーフ・オブ・ステークへの移行による影響を受けませんでした(DIFFICULTYオペコードの戻り値を除く)。 ## 9 実行モデル {#9-execution-model} -このセクション(p. 12-14)には、EVMの定義のほとんどが記述されています。 +このセクション(12~14ページ)には、EVMの定義のほとんどが含まれています。 -_システム状態_とは、システムを実行するため必要なすべての情報を指します。 典型的なコンピュータでは、これはメモリやレジスタの内容などです。 +_システム状態_という用語には、システムの実行に必要なすべての情報が含まれます。 典型的なコンピュータでは、これはメモリやレジスタの内容などを意味します。 -[チューリングマシン](https://en.wikipedia.org/wiki/Turing_machine)は、計算モデルです。 チューリングマシンは、コンピュータを本質的に単純化したもので、通常のコンピュータと同じ計算を実行する能力があることが証明されています。つまり、コンピュータが計算できるものはすべてチューリングマシンでも計算でき、またその逆も同様です。 このモデルは、さまざまな定理で何が計算可能で何が計算不可能であるかを証明するのに役立ちます。 +[チューリングマシン](https://en.wikipedia.org/wiki/Turing_machine)は計算モデルです。 本質的に、これはコンピュータの簡易版であり、通常のコンピュータと同じ計算を実行する能力があることが証明されています(コンピュータが計算できるものはすべてチューリングマシンでも計算でき、その逆も同様です)。 このモデルは、計算可能なものと計算不可能なものに関するさまざまな定理の証明を容易にします。 -[チューリング完全](https://en.wikipedia.org/wiki/Turing_completeness)とは、チューリングマシンと同じ計算を実行できるコンピュータのことを指します。 チューリングマシンは無限ループができますが、EVMではガスがなくなると無限ループができません。そのため、EVMは準チューリング完全であるといわれています。 +[チューリング完全](https://en.wikipedia.org/wiki/Turing_completeness)という用語は、チューリングマシンと同じ計算を実行できるコンピュータを意味します。 チューリングマシンは無限ループに陥ることがありますが、EVMはガスがなくなるため無限ループに陥ることができず、準チューリング完全であるにすぎません。 -## 9.1 基本事項 {#91-basics} +## 9.1 基本 {#91-basics} -このセクションでは、EVMの基本事項と、EVMと他の計算モデルとの比較について説明しています。 +このセクションでは、EVMの基本と、他の計算モデルとの比較について説明します。 -[スタックマシン](https://en.wikipedia.org/wiki/Stack_machine)は、中間データをレジスタではなく[**スタック**](https://en.wikipedia.org/wiki/Stack_(abstract_data_type))に格納するコンピュータです。 これは、仮想マシンで好まれるアーキテクチャです。なぜなら、実装が簡単で、バグやセキュリティの脆弱性が発生する可能性を大幅に低くできるためです。 スタック内のメモリは、256ビットのワードに分割されます。 256ビットが選ばれた理由としては、Kecck-256ハッシュや楕円曲線計算など、イーサリアムの中核となる暗号操作に都合が良いためです。 スタックの最大サイズは、1024バイトです。 オペコード実行時、通常、スタックからパラメータを取得します。 `POP`(スタックの先頭のアイテムの削除)、`DUP_N`(スタックのN番目のアイテムの複製)など、スタック内の要素を再構成するための専用オペコードがあります。 +[スタックマシン](https://en.wikipedia.org/wiki/Stack_machine)とは、中間データをレジスタではなく[**スタック**](https://en.wikipedia.org/wiki/Stack_\(abstract_data_type\))に格納するコンピュータです。 これは実装が容易で、バグやセキュリティの脆弱性がはるかに少なくなるため、仮想マシンで好まれるアーキテクチャです。 スタック内のメモリは、256ビットのワードに分割されます。 これは、Keccak-256のハッシュ化や楕円曲線計算など、イーサリアムの中核となる暗号操作に便利であるため、選択されました。 スタックの最大サイズは1024アイテム(1024 x 256ビット)です。 オペコードが実行されるとき、通常はスタックからパラメータを取得します。 `POP`(スタックの先頭からアイテムを削除)、`DUP_N`(スタックのN番目のアイテムを複製)など、スタック内の要素を再編成するための専用オペコードがあります。 -EVMには、 実行中にデータを保存するために使用される**メモリ**と呼ばれる揮発性スペースもあります。 このメモリは、32バイトのワードで構成されます。 すべてのメモリのロケーションは、ゼロで初期化されます。 次の[Yul](https://docs.soliditylang.org/en/latest/yul.html)コードを実行してメモリにワードを追加すると、32バイトのメモリのワード内にある空スペースがパディングによってゼロで埋められます。つまり、ロケーション0~29、0x60~30、0xA7~31にゼロが含まれる1つのワードが作成されます。 +EVMには、実行中にデータを保存するために使用される**メモリ**と呼ばれる揮発性スペースもあります。 このメモリは、32バイトのワードで構成されます。 すべてのメモリロケーションはゼロで初期化されます。 この[Yul](https://docs.soliditylang.org/en/latest/yul.html)コードを実行してメモリにワードを追加すると、ワード内の空きスペースがゼロでパディングされて32バイトのメモリが埋められます。つまり、ロケーション0-29はゼロ、30は0x60、31は0xA7である1ワードが作成されます。 ```yul mstore(0, 0x60A7) ``` -EVMは、メモリとやり取りをする3つのオペコードを提供しています。そのうちの1つが`mstore`で、ワードをメモリにロードします。 他の2つは、1バイトをメモリにロードする`mstore8`、ワードをメモリからスタックに移動する`mload`です。 +`mstore`は、EVMがメモリと対話するために提供する3つのオペコードの1つで、ワードをメモリにロードします。 他の2つは、1バイトをメモリにロードする`mstore8`と、メモリからスタックにワードを移動する`mload`です。 -EVMには、システム状態の一部として保持される独自の不揮発性**ストレージ**モデルもあります。このメモリは、(ワードアドレス可能なスタック内のバイト配列とは違い)ワードの配列で構成されます。 このストレージは、コントラクトが永続データを保存する場所です。コントラクトは、自分のストレージとしかやり取りできません。 ストレージは、キーと値のマッピングで構成されます。 +EVMには、システム状態の一部として維持される、独立した不揮発性の**ストレージ**モデルもあります。このメモリは、(スタック内のワードアドレス指定可能なバイト配列とは対照的に)ワード配列として構成されます。 このストレージは、コントラクトが永続データを保持する場所であり、コントラクトは自身のストレージとのみ対話できます。 ストレージは、キーと値のマッピングで構成されます。 -イエローペーパーのこのセクションでは言及されていませんが、メモリに4番目のタイプがあることを知っておくといいでしょう。 **Calldata**は、トランザクションの`data`パラメータで渡された値を保存するために使用される、バイトアドレス可能な読み取り専用のメモリです。 EVMには、`calldata`を管理する専用のオペコードがあります。 `calldatasize`は、そのデータのサイズを返します。 `calldataload`は、そのデータをスタックにロードします。 `calldatacopy`は、そのデータをメモリにコピーします。 +イエローペーパーのこのセクションでは言及されていませんが、4番目のタイプのメモリがあることを知っておくと便利です。 **Calldata**は、トランザクションの`data`パラメータで渡された値を格納するために使用される、バイトアドレス指定可能な読み取り専用メモリです。 EVMには、`calldata`を管理するための特定のオペコードがあります。 `calldatasize`は、データのサイズを返します。 `calldataload`は、データをスタックにロードします。 `calldatacopy`は、データをメモリにコピーします。 -標準の[フォンノイマン型アーキテクチャ](https://en.wikipedia.org/wiki/Von_Neumann_architecture)では、コードとデータが同じメモリに保存されます。 しかし、EVMでは、セキュリティ上の理由からこの標準に準拠していません。なぜなら、揮発性メモリを共有すると、プログラムのコードが変更される可能性があるからです。 そのため、コードはストレージに保存されます。 +標準の[フォン・ノイマン・アーキテクチャ](https://en.wikipedia.org/wiki/Von_Neumann_architecture)では、コードとデータが同じメモリに格納されます。 EVMはセキュリティ上の理由からこの標準に従いません。揮発性メモリを共有すると、プログラムコードが変更される可能性があるためです。 代わりに、コードはストレージに保存されます。 コードがメモリから実行されるのは、次の2つのケースだけです。 -- コントラクトが他のコントラクトを作成する場合([`CREATE`](https://www.evm.codes/#f0) または[`CREATE2`](https://www.evm.codes/#f5)を使用)、コントラクトにあるコンストラクタのコードはメモリから取得されます。 -- _あらゆる_コントラクトの作成において、コンストラクタのコードが実行され、メモリから実際のコントラクトのコードが返されます。 +- コントラクトが別のコントラクトを作成する場合([`CREATE`](https://www.evm.codes/#f0)または[`CREATE2`](https://www.evm.codes/#f5)を使用)、コントラクトコンストラクタのコードはメモリから取得されます。 +- コントラクトの作成中、コンストラクタコードが実行され、実際のコントラクトのコードとともにメモリから返されます。 -例外実行とは、現在のコントラクトの実行を停止させる例外を意味します。 +例外実行という用語は、現在のコントラクトの実行を停止させる例外を意味します。 -## 9.2 フィーの概要 {#92-fees-overview} +## 9.2 手数料の概要 {#92-fees-overview} -このセクションでは、ガス代の計算方法について説明しています。 次の3つのコストがあります。 +このセクションでは、ガス代の計算方法について説明します。 次の3つのコストがあります。 -### オペコードコスト {#opcode-cost} +### オペコードのコスト {#opcode-cost} -特定のオペコードで発生する固有のコストです。 この値を取得するには、付録H(ページ28)の式(327)の下部でオペコードのコストグループを見つけます。そして、式(324)でコストグループを見つけます。 ここには、コスト関数があります。ほとんどのケースにおいて、付録G(ページ27)のパラメータを使用します。 +特定のオペコードで発生する固有のコストです。 この値を取得するには、付録H(28ページ、式(327)の下)でオペコードのコストグループを見つけ、式(324)でコストグループを見つけます。 これによりコスト関数が得られますが、ほとんどの場合、付録G(27ページ)のパラメータを使用します。 -例えば、オペコード[`CALLDATACOPY`](https://www.evm.codes/#37)は、_Wcopy_グループのメンバーです。 このグループにおけるオペコードのコストは、_Gverylow+Gcopy×⌈μs[2]÷32⌉_となります。 付録Gを見ると、両方の定数が3であることがわかり、この式は、_3+3×⌈μs[2]÷32⌉_です。 +例えば、オペコード[`CALLDATACOPY`](https://www.evm.codes/#37)は、グループ_Wcopy_のメンバーです。 このグループにおけるオペコードのコストは、_Gverylow+Gcopy×⌈μs[2]÷32⌉_となります。 付録Gを見ると、両方の定数が3であることがわかり、この式は_3+3×⌈μs[2]÷32⌉_です。 -また、_⌈μs[2]÷32⌉_という式を解読する必要があります。 一番外側の部分の _⌈ \ ⌉_は、天井関数です。この関数に値を指定すると、その値以上の最小の整数を返します。 例えば、_⌈2.5⌉ = ⌈3⌉ = 3_となります。 この式の内側部分は、_μs[2]÷32_です。 ページ3のセクション3(慣習)を参照してください。_μ_は、マシンの状態を表します。 マシンの状態は、ページ13のセクション9.4.1で定義されています。 そのセクションによると、マシンの状態パラメータの1つは、スタックの_s_になります。 したがって、_μs[2]_ は、スタックの2番目のロケーションにあるということです。 こちらの[オペコード](https://www.evm.codes/#37)では、スタック内のロケーション#2に、データのサイズ(バイト単位)が格納されています。 グループWの他のオペコードcopyである[`CODECOPY`](https://www.evm.codes/#39)と[`RETURNDATACOPY`](https://www.evm.codes/#3e)も、同じロケーションにデータのサイズを格納しています。 したがって、_⌈μs[2]÷32⌉_ は、コピーされるデータを保存するために必要になる32バイトのワード数です。 以上から、[`CALLDATACOPY`](https://www.evm.codes/#37)に固有のコストは、3ガスにコピーされるデータのワードごとに3ガスを加えたものになります。 +次に、式_⌈μs[2]÷32⌉_を解読する必要があります。 外側の部分_⌈ \ ⌉_は天井関数であり、与えられた値に対して、その値以上である最小の整数を返す関数です。 例えば、_⌈2.5⌉ = ⌈3⌉ = 3_となります。 内側の部分は、_μs[2]÷32_です。 3ページ目のセクション3(表記法)を見ると、_μ_はマシンの状態です。 マシンの状態は、13ページのセクション9.4.1で定義されています。 そのセクションによると、マシンの状態パラメータの1つはスタックの_s_です。 すべてをまとめると、_μs[2]_はスタック内のロケーション#2であるようです。 [このオペコード](https://www.evm.codes/#37)を見ると、スタック内のロケーション#2はデータのサイズ(バイト単位)です。 グループWcopyの他のオペコード、[`CODECOPY`](https://www.evm.codes/#39)および[`RETURNDATACOPY`](https://www.evm.codes/#3e)を見ると、それらも同じロケーションにデータサイズを持っています。 したがって、_⌈μs[2]÷32⌉_は、コピーされるデータを保存するために必要な32バイトのワード数です。 すべてをまとめると、[`CALLDATACOPY`](https://www.evm.codes/#37)の固有コストは3ガスに加えて、コピーされるデータのワードごとに3ガスです。 ### 実行コスト {#running-cost} 呼び出すコードの実行コスト。 -- [`CREATE`](https://www.evm.codes/#f0)および[`CREATE2`](https://www.evm.codes/#f5)の場合は、新しいコントラクトのコンストラクタ -- [`CALL`](https://www.evm.codes/#f1)、[`CALLCODE`](https://www.evm.codes/#f2)、[`STATICCALL`](https://www.evm.codes/#fa)、[`DELEGATECALL`](https://www.evm.codes/#f4)の場合は、呼び出すコントラクト +- [`CREATE`](https://www.evm.codes/#f0)と[`CREATE2`](https://www.evm.codes/#f5)の場合、新しいコントラクトのコンストラクタ。 +- [`CALL`](https://www.evm.codes/#f1)、[`CALLCODE`](https://www.evm.codes/#f2)、[`STATICCALL`](https://www.evm.codes/#fa)、または[`DELEGATECALL`](https://www.evm.codes/#f4)の場合、呼び出すコントラクト。 -### メモリーコストの拡張 {#expanding-memory-cost} +### メモリ拡張コスト {#expanding-memory-cost} -(必要な場合の)メモリ拡張におけるコストについて。 +(必要な場合の)メモリ拡張のコスト。 -この値は、式324で_Cmem(μi')-Cmem(μi)_として記述されています。 セクション9.4.1をもう一度見てみましょう。_μi_は、メモリ内のワード数であることがわかります。 そのため_μi_は、オペコードの前のメモリ内のワード数となります。また、_μi '_は、オペコード後のメモリ内のワード数を表します。 +式324では、この値は_Cmem(μi')-Cmem(μi)_として記述されています。 セクション9.4.1をもう一度見ると、_μi_はメモリ内のワード数であることがわかります。 したがって、_μi_はオペコード実行前のメモリ内のワード数であり、_μi'_はオペコード実行後のメモリ内のワード数です。 -関数_Cmem_は、式326で次のように定義されます。_Cmem (a) = Gmemory × a + ⌊a2 ÷ 512⌋_ _⌊x⌋_は、床関数を表します。これは値を指定すると、その値以下の最大の整数を返す関数です。 例えば、 _⌊2.5⌋ = ⌊2⌋ = 2_となります。 _a < √512_のときは、 _a2 < 512_となり、この床関数の結果はゼロとなります。 そのため、最初の22ワード(704 バイト)については、必要なメモリワード数に応じてコストが線形的に増加します。 そのワード数を超えると、_⌊a2 ÷ 512⌋_が正になります。 必要なメモリが大きい場合、ガスコストがメモリ量の2乗に比例します。 +関数_Cmem_は、式326で次のように定義されます:_Cmem(a) = Gmemory × a + ⌊a2 ÷ 512⌋_。 _⌊x⌋_は床関数で、与えられた値に対して、その値以下である最大の整数を返す関数です。 例えば、_⌊2.5⌋ = ⌊2⌋ = 2_。_a < √512_の場合、_a2 < 512_となり、床関数の結果はゼロになります。 そのため、最初の22ワード(704バイト)については、必要なメモリワード数に応じてコストが線形的に増加します。 その点を超えると、_⌊a2 ÷ 512⌋_は正になります。 必要なメモリが十分に大きい場合、ガスコストはメモリ量の2乗に比例します。 -これらの要素は、_固有_のガス代にのみ影響を与えることに**注意してください**。フィーマーケットやバリデータへのチップは、エンドユーザーが支払う必要がある金額を決定する要素であり、この式には含まれていません。この式は、EVMで特定の操作を実行するための直接コストのみを表しています。 +**注**:これらの要素は_固有の_ガス代にのみ影響し、エンドユーザーが支払う必要のある金額を決定する手数料マーケットやバリデータへのチップは考慮されていません。これは、EVMで特定の操作を実行するための生のコストにすぎません。 [ガスについての詳細](/developers/docs/gas/) ## 9.3 実行環境 {#93-execution-env} -実行環境は、_I_で表します。これは、ブロックチェーンの状態やEVMの以外の情報を含みます。 - -| パラメータ | データにアクセスするためのオペコード | データにアクセスするためのSolidityのコード | -| --------------- | ----------------------------------------------------------------------------------------------- | ------------------------------------ | -| _Ia_ | [`ADDRESS`](https://www.evm.codes/#30) | `address(this)` | -| _Io_ | [`ORIGIN`](https://www.evm.codes/#32) | `tx.origin` | -| _Ip_ | [`GASPRICE`](https://www.evm.codes/#3a) | `tx.gasprice` | -| _Id_ | [`CALLDATALOAD`](https://www.evm.codes/#35), etc. | `msg.data` | -| _Is_ | [`CALLER`](https://www.evm.codes/#33) | `msg.sender` | -| _Iv_ | [`CALLVALUE`](https://www.evm.codes/#34) | `msg.value` | -| _Ib_ | [`CODECOPY`](https://www.evm.codes/#39) | `address(this).code` | -| _IH_ | ブロックヘッダーフィールド、[`NUMBER`](https://www.evm.codes/#43)や[`DIFFICULTY`](https://www.evm.codes/#44)など | `block.number`, `block.difficulty`など | -| _Ie_ | コントラクト間のコールのコールスタックの深さ(コントラクトの作成を含む) | | -| _Iw_ | EVMの状態の変更を許可されているか、もしくは静的に実行されているか | | - -セクション9の続きを理解するには、次にある他のパラメータのいくつかを理解する必要があります。 - -| パラメータ | 定義されているセクション | 説明 | -| ----- | ------------- | ------------------------------------------------------------------------------------------------ | -| _σ_ | 2(2ページ目, 数式1) | ブロックチェーンの状態 | -| _g_ | 9.3(13ページ目) | ガスの残量 | -| _A_ | 6.1(8ページ目) | 発生したサブ状態(トランザクション終了時にスケジュールされた変更) | -| _o_ | 9.3(13ページ目) | 出力 - 内部トランザクションの場合に返される結果(あるコントラクトが別のコントラクトを呼び出すとき)およびビュー関数の呼び出し(情報を求めるだけなので、トランザクションを待つ必要がない場合) | +実行環境は、ブロックチェーンの状態やEVMの一部ではない情報を含むタプル_I_です。 + +| パラメータ | データにアクセスするためのオペコード | データにアクセスするためのSolidityのコード | +| --------------- | ------------------------------------------------------------------------------------------------ | ----------------------------------- | +| _Ia_ | [`ADDRESS`](https://www.evm.codes/#30) | `address(this)` | +| _Io_ | [`ORIGIN`](https://www.evm.codes/#32) | `tx.origin` | +| _Ip_ | [`GASPRICE`](https://www.evm.codes/#3a) | `tx.gasprice` | +| _Id_ | [`CALLDATALOAD`](https://www.evm.codes/#35)など | `msg.data` | +| _Is_ | [`CALLER`](https://www.evm.codes/#33) | `msg.sender` | +| _Iv_ | [`CALLVALUE`](https://www.evm.codes/#34) | `msg.value` | +| _Ib_ | [`CODECOPY`](https://www.evm.codes/#39) | `address(this).code` | +| _IH_ | ブロックヘッダーフィールド([`NUMBER`](https://www.evm.codes/#43)や[`DIFFICULTY`](https://www.evm.codes/#44)など) | `block.number`、`block.difficulty`など | +| _Ie_ | コントラクト間のコールのコールスタックの深さ(コントラクトの作成を含む) | | +| _Iw_ | EVMが状態を変更できるか、静的に実行されているか | | + +セクション9の残りを理解するには、他にいくつかのパラメータが必要です。 + +| パラメータ | 定義されているセクション | 意味 | +| ----- | -------------------------------------------------------------- | ----------------------------------------------------------------------------------------- | +| _σ_ | 2 (p. 2, equation 1) | ブロックチェーンの状態 | +| _g_ | 9.3 (p. 13) | 残りのガス | +| _A_ | 6.1 (p. 8) | 発生したサブ状態(トランザクション終了時に予定されている変更) | +| _o_ | 9.3 (p. 13) | 出力 - 内部トランザクション(あるコントラクトが別のコントラクトを呼び出す場合)やビュー関数の呼び出し(情報を要求するだけでトランザクションを待つ必要がない場合)で返される結果 | ## 9.4 実行の概要 {#94-execution-overview} -それでは準備が整ったので、ようやくEVMがどのように機能するかについての説明を開始します。 +すべての準備が整ったので、いよいよEVMの仕組みについて取り組んでいきます。 -式137~142は、EVMを実行するための次の初期条件を示しています。 +式137~142は、EVMを実行するための初期条件を示しています。 -| Symbol | 初期値 | 説明 | -| ---------------- | ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| _μg_ | _g_ | ガスの残量 | -| _μpc_ | _0_ | プログラムカウンタ、実行する次の命令が格納されたアドレス | -| _μm_ | _(0, 0, ...)_ | メモリ、ゼロで初期化 | -| _μi_ | _0_ | 使用される最上位のメモリ位置 | -| _μs_ | _()_ | スタック、初期値は空 | -| _μo_ | _∅_ | 戻りデータ([`RETURN`](https://www.evm.codes/#f3)または[`REVERT`](https://www.evm.codes/#fd))もしくは戻りデータ無し([`STOP`](https://www.evm.codes/#00)または[`SELFDESTRUCT`](https://www.evm.codes/#ff))で止めない限り、戻りデータは空の出力 | +| 記号 | 初期値 | 意味 | +| ---------------- | -------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| _μg_ | _g_ | 残りのガス | +| _μpc_ | _0_ | プログラムカウンタ、実行する次の命令のアドレス | +| _μm_ | _(0, 0, ...)_ | メモリ、すべてゼロに初期化 | +| _μi_ | _0_ | 使用される最上位のメモリ位置 | +| _μs_ | _()_ | スタック、最初は空 | +| _μo_ | _∅_ | 出力、戻りデータで停止する([`RETURN`](https://www.evm.codes/#f3)または[`REVERT`](https://www.evm.codes/#fd))か、戻りデータなしで停止する([`STOP`](https://www.evm.codes/#00)または[`SELFDESTRUCT`](https://www.evm.codes/#ff))まで空集合 | -式143では、実行中の各時点で4つ状態が発生する可能性があること、そしてそれらをどのように処理するかを示しています。 +式143は、実行中の各時点で4つの可能な条件があり、それらをどう処理するかを示しています。 -1. `Z(σ,μ,A,I)` Zは関数を表しており、操作によって無効な状態遷移が発生するかどうかをテストします([例外による停止](#942-Exceptional-halting)を参照)。 Trueと評価された場合、変更が行われていないため、新しい状態は古い状態と同じです (ガスがバーンされることは除く) 。 -2. 実行されているオペコードが[`REVERT`](https://www.evm.codes/#fd)の場合は、ガスが失われ、新しい状態と古い状態は同一になります。 -3. 一連の演算が終了すると、[`RETURN`](https://www.evm.codes/#f3)で示されるように、状態は新しい状態に更新されます。 -4. 終了条件1~3のいずれでもない場合は、実行を続けます。 +1. `Z(σ,μ,A,I)` Zは、操作が無効な状態遷移を引き起こすかどうかをテストする関数を表します([例外的な停止](#942-exceptional-halting)を参照)。 Trueと評価された場合、変更が実装されていないため、新しい状態は古い状態と同一です(ガスがバーンされる場合を除く)。 +2. 実行中のオペコードが[`REVERT`](https://www.evm.codes/#fd)の場合、新しい状態は古い状態と同じで、一部のガスが失われます。 +3. [`RETURN`](https://www.evm.codes/#f3)で示されるように、操作のシーケンスが終了した場合、状態は新しい状態に更新されます。 +4. 終了条件1~3のいずれでもない場合は、実行を続けます。 ## 9.4.1 マシンの状態 {#941-machine-state} -このセクションでは、マシンの状態について詳しく説明します。 ここでは、_w_が現在のオペコードであることを規定しています。 _μpc_がコードの長さを示す_||Ib|| 未満の場合_、そのバイト(_Ib[μpc]_)は、オペコードです。 それ以外の場合、オペコードは[`STOP`](https://www.evm.codes/#00)と定義されています。 +このセクションでは、マシンの状態について詳しく説明します。 これは、_w_が現在のオペコードであることを指定します。 _μpc_がコードの長さである_||Ib||_より小さい場合、そのバイト(_Ib[μpc]_)がオペコードです。 それ以外の場合、オペコードは[`STOP`](https://www.evm.codes/#00)として定義されます。 -[スタックマシン](https://en.wikipedia.org/wiki/Stack_machine)であるため、ポップアウトされたアイテムの数(_δ_)と各オペコードによってプッシュインされたアイテムの数(_α_)を追跡する必要があります。 +これは[スタックマシン](https://en.wikipedia.org/wiki/Stack_machine)であるため、各オペコードによってポップアウトされたアイテムの数(_δ_)とプッシュインされたアイテムの数(_α_)を追跡する必要があります。 -## 9.4.2 例外による停止 {#942-exceptional-halt} +## 9.4.2 例外的な停止 {#942-exceptional-halt} -このセクションでは、異常終了がいつ発生するかを規定する_Z_関数を定義しています。 これは [Boolean](https://en.wikipedia.org/wiki/Boolean_data_type)関数であり、[論理和では_∨_](https://en.wikipedia.org/wiki/Logical_disjunction)を使用します。また、[論理積では_∧_](https://en.wikipedia.org/wiki/Logical_conjunction)を使用します。 +このセクションでは、異常終了が発生するタイミングを指定する_Z_関数を定義します。 これは[ブール](https://en.wikipedia.org/wiki/Boolean_data_type)関数なので、[論理和には_∨_](https://en.wikipedia.org/wiki/Logical_disjunction)を、[論理積には_∧_](https://en.wikipedia.org/wiki/Logical_conjunction)を使用します。 -次のいずれかの条件が真になる場合、例外による停止をします。 +次のいずれかの条件が真になる場合、例外による停止が発生します。 -- **_μg < C(σ,μ,A,I)_** セクション9.2に書かれているように、_C_はガスのコストを規定する関数です。 次のオペコードを実施するのに十分なガスが残っていない場合の条件です。 +- **_μg < C(σ,μ,A,I)_** + セクション9.2で見たように、_C_はガス代を指定する関数です。 次のオペコードをカバーするのに十分なガスが残っていません。 -- **_δw=∅_** オペコードに対してポップされるアイテムの数が未定義の場合、オペコード自体も未定義となります。 +- **_δw=∅_** + オペコードに対してポップされるアイテムの数が未定義の場合、オペコード自体も未定義です。 -- **_|| μs || < δw_** スタックのアンダーフロー。現在のオペコードに対してスタック内に十分なアイテムがありません。 +- **_|| μs || < δw_** + スタックアンダーフロー。現在のオペコードに対してスタック内に十分なアイテムがありません。 -- **_w = JUMP ∧ μs[0]∉D(Ib)_** オペコードが[`JUMP`](https://www.evm.codes/#56)で、またアドレスが[`JUMPDEST`](https://www.evm.codes/#5b)でない場合です。 ジャンプは、ジャンプ先が[`JUMPDEST`](https://www.evm.codes/#5b)のとき_のみ_有効です。 +- **_w = JUMP ∧ μs[0]∉D(Ib)_** + オペコードが[`JUMP`](https://www.evm.codes/#56)で、アドレスが[`JUMPDEST`](https://www.evm.codes/#5b)ではありません。 ジャンプは、ジャンプ先が[`JUMPDEST`](https://www.evm.codes/#5b)のときのみ有効です。 -- **_w = JUMPI ∧ μs[1]≠0 ∧ μs[0] ∉ D(Ib)_** オペコードが [`JUMPI`](https://www.evm.codes/#57)であり、条件が真(ゼロ以外)であるため、ジャンプが発生しますが、[`JUMPDEST`](https://www.evm.codes/#5b)がアドレスではありません。 ジャンプは、ジャンプ先が[`JUMPDEST`](https://www.evm.codes/#5b)のとき_のみ_有効です。 +- **_w = JUMPI ∧ μs[1]≠0 ∧ μs[0] ∉ D(Ib)_** + オペコードが[`JUMPI`](https://www.evm.codes/#57)で、条件が真(非ゼロ)であるためジャンプが発生しますが、アドレスが[`JUMPDEST`](https://www.evm.codes/#5b)ではありません。 ジャンプは、ジャンプ先が[`JUMPDEST`](https://www.evm.codes/#5b)のときのみ有効です。 -- **_w = RETURNDATACOPY ∧ μs[1]+μs[2]>|| μo ||_** オペコードは、[`RETURNDATACOPY`](https://www.evm.codes/#3e)です。 このオペコードでは、スタックの要素_μs[1]_は、戻り値データのバッファ内からの読み取り位置です。そしてスタックの要素 _μs[2]_はデータの長さです。 この条件は、戻りデータのバッファの末尾を超えて読み取ろうとしたときに発生します。 コールデータやコード自体には類似した条件がないことに注意してください。 これらのバッファの末尾を超えて読み取ろうとすると、ゼロが返されるだけです。 +- **_w = RETURNDATACOPY ∧ μs[1]+μs[2]>|| μo ||_** + オペコードは[`RETURNDATACOPY`](https://www.evm.codes/#3e)です。 このオペコードでは、スタック要素_μs[1]_は戻りデータバッファから読み取るオフセットで、スタック要素_μs[2]_はデータの長さです。 この条件は、戻りデータバッファの末尾を超えて読み取ろうとしたときに発生します。 コールデータやコード自体には同様の条件がないことに注意してください。 これらのバッファの末尾を超えて読み取ろうとすると、ゼロが返されるだけです。 - **_|| μs || - δw + αw > 1024_** - スタックオーバーフロー オペコードの実行で1024を超えるアイテムのスタックが生成された場合は、中断されます。 + スタックオーバーフロー。 オペコードの実行で1024を超えるアイテムのスタックが生成された場合は、中断されます。 -- **_¬Iw ∧ W(w,μ)_** 静的に実行しようとしていますか? ([¬は否定を表します](https://en.wikipedia.org/wiki/Negation) 。また、ブロックチェーンの状態を変更できる場合_Iw_が真になります) そのような場合、状態の変更操作を試行しようとしてもできません。 +- **_¬Iw ∧ W(w,μ)_** + 静的に実行していますか([¬は否定](https://en.wikipedia.org/wiki/Negation)で、ブロックチェーンの状態を変更できる場合に_Iw_は真になります)? その場合、状態変更操作を試行しようとしてもできません。 - 関数_W(w,μ)_は、この後に式150にて定義されています。 次の条件が真の場合、_W(w,μ)_が真になります。 + 関数_W(w,μ)_は、後の式150で定義されています。 次のいずれかの条件が真の場合、_W(w,μ)_は真になります。 - - **_w ∈ \{CREATE, CREATE2, SSTORE, SELFDESTRUCT}_** これらのオペコードは、新しいコントラクトの作成、値の保存、現在のコントラクトの破棄によって状態を変更します。 + - **_w ∈ \{CREATE, CREATE2, SSTORE, SELFDESTRUCT}_** + これらのオペコードは、新しいコントラクトの作成、値の保存、または現在のコントラクトの破棄によって状態を変更します。 - - **_LOG0≤w ∧ w≤LOG4_** 静的に呼び出した場合、ログエントリは出力されません。 [`LOG0` (A0)](https://www.evm.codes/#a0)から[`LOG4` (A4)](https://www.evm.codes/#a4)の間における範囲内に全てのログオペコードがあります。 ログオペコードの後にある数字は、ログエントリに含まれるトピックの数を規定しています。 - - **_w=CALL ∧ μs[2]≠0_** 静的な場合、他のコントラクトは呼び出せますが、ETHの送金はできません。 + - **_LOG0≤w ∧ w≤LOG4_** + 静的に呼び出された場合、ログエントリを出力できません。 + ログオペコードはすべて、[`LOG0` (A0)](https://www.evm.codes/#a0)から[`LOG4` (A4)](https://www.evm.codes/#a4)の範囲にあります。 + ログオペコードの後の数字は、ログエントリに含まれるトピックの数を指定します。 -- **_w = SSTORE ∧ μg ≤ Gcallstipend_** Gcallstipend(付録Gで2300で定義)以上のガスがなければ、[`SSTORE`](https://www.evm.codes/#55)を実行することはできません。 + - **_w=CALL ∧ μs[2]≠0_** + 静的な場合、別のコントラクトを呼び出すことはできますが、ETHをそれに送金することはできません。 + +- **_w = SSTORE ∧ μg ≤ Gcallstipend_** + Gcallstipend(付録Gで2300と定義)を超えるガスがない限り、[`SSTORE`](https://www.evm.codes/#55)は実行できません。 ## 9.4.3 ジャンプ先の有効性 {#943-jump-dest-valid} -ここでは、[`JUMPDEST`](https://www.evm.codes/#5b)オペコードについて形式的に定義します。 バイト値0x5Bを単純に見つけることはできません。なぜなら、バイト値0x5Bは、PUSH内にある可能性があるためです(つまり、オペコードではなくデータ)。 +ここでは、[`JUMPDEST`](https://www.evm.codes/#5b)オペコードについて正式に定義します。 バイト値0x5Bを単純に探すことはできません。PUSHの内部にある可能性があり(したがってオペコードではなくデータ)、そのためです。 -式(153)では、関数_N(i,w)_を定義します。 最初のパラメータ _i_ は、オペコードのロケーションです。 2番目のパラメータ_w_は、そのオペコードです。 _w∈[PUSH1, PUSH32]_の場合、オペコードがPUSHであることを意味します(角括弧は端点を含む範囲を定義しています)。 この場合では、次のオペコードが_i+2+(w−PUSH1)_になります。 [`PUSH1`](https://www.evm.codes/#60)では、2バイト(PUSH自体と1バイトの値)進む必要があります。[`PUSH2`](https://www.evm.codes/#61)では、2バイトの値であるため、3バイト進める必要があります。 他のすべてのEVMオペコードの長さは1バイトであるため、その他のすべてのケースにおいては_N(i,w)=i+1_となります。 +式(153)では、関数_N(i,w)_を定義します。 最初のパラメータ_i_は、オペコードのロケーションです。 2番目のパラメータ_w_は、オペコード自体です。 _w∈[PUSH1, PUSH32]_の場合、オペコードがPUSHであることを意味します(角括弧は端点を含む範囲を定義しています)。 その場合、次のオペコードは_i+2+(w−PUSH1)_にあります。 [`PUSH1`](https://www.evm.codes/#60)では、2バイト(PUSH自体と1バイトの値)進む必要があります。[`PUSH2`](https://www.evm.codes/#61)では、2バイトの値であるため、3バイト進める必要があります。 他のすべてのEVMオペコードは1バイト長なので、他のすべてのケースでは_N(i,w)=i+1_です。 -この関数は、式(152)で_DJ(c,i)_と定義され、コード_c_内のすべての有効なジャンプ先の[集合](https://en.wikipedia.org/wiki/Set_(mathematics))で、オペコードのロケーション_i_から始まります。 この関数は、再帰的に定義されています。 _i≥||c||_では、コードが終了していることを意味します。 そのため、これ以上のジャンプ先は存在しないので、空集合を返すだけです。 +この関数は、式(152)で_DJ(c,i)_を定義するために使用されます。これは、コード_c_内のすべての有効なジャンプ先の[集合](https://en.wikipedia.org/wiki/Set_\(mathematics\))であり、オペコードのロケーション_i_から始まります。 この関数は、再帰的に定義されています。 _i≥||c||_の場合、コードの末尾またはそれ以降にいることを意味します。 これ以上ジャンプ先は見つからないので、空集合を返すだけです。 -それ以外の場合は、次のオペコードに移動し、そこから始まる集合を取得することで、コードの残りの部分を調べます。 現在のオペコードが_c[i]_であるため、次のオペコードのロケーションは、_N(i,c[i])_になります。 したがって、_DJ(c,N(i,c[i]))_は、次のオペコードから始まる有効なジャンプ先の集合です。 現在のオペコードが`JUMPDEST`でなければ、その集合を返すだけです。 `JUMPDEST`であれば、結果の集合にそれを含めて返します。 +それ以外のすべてのケースでは、次のオペコードに移動し、そこから始まる集合を取得することで、コードの残りの部分を調べます。 _c[i]_は現在のオペコードなので、_N(i,c[i])_は次のオペコードのロケーションです。 したがって、_DJ(c,N(i,c[i]))_は、次のオペコードから始まる有効なジャンプ先の集合です。 現在のオペコードが`JUMPDEST`でなければ、その集合を返すだけです。 `JUMPDEST`であれば、結果の集合にそれを含めて返します。 -## 9.4.4 通常停止 {#944-normal-halt} +## 9.4.4 通常の停止 {#944-normal-halt} -停止関数である_H_は、3つの型の値を返すことができます。 +停止関数_H_は、3つの型の値を返すことができます。 -- 停止オペコードでない場合は、空のセットである_∅_を返します。 慣例により、この値はブール型の偽(false)として解釈されます。 -- 出力を生成しない停止オペコードの場合、([`STOP`](https://www.evm.codes/#00)または[`SELFDESTRUCT`](https://www.evm.codes/#ff))、サイズがゼロバイトのシーケンスを戻り値として返します。 これは空のセットとは、大きく異なることに注意してください。 この値は、EVMが実際に停止し、読み取る戻りデータがないことを意味します。 -- 出力を生成する停止オペコードがある場合([`RETURN`](https://www.evm.codes/#f3)または [`REVERT`](https://www.evm.codes/#fd))、そのオペコードで指定されたバイトのシーケンスを返します。 このシーケンスはメモリから取り出され、スタックの先頭の値(_μs[0]_)が最初のバイトであり、その後の値(_μs[1]_)は長さです。 +- 停止オペコードでない場合は、空集合である_∅_を返します。 慣例により、この値はブール型の偽(false)として解釈されます。 +- 出力を生成しない停止オペコード([`STOP`](https://www.evm.codes/#00)または[`SELFDESTRUCT`](https://www.evm.codes/#ff))がある場合、戻り値としてサイズがゼロバイトのシーケンスを返します。 これは空集合とは大きく異なることに注意してください。 この値は、EVMが実際に停止したことを意味しますが、読み取る戻りデータはありません。 +- 出力を生成する停止オペコード([`RETURN`](https://www.evm.codes/#f3)または[`REVERT`](https://www.evm.codes/#fd))がある場合、そのオペコードで指定されたバイトのシーケンスを返します。 このシーケンスはメモリから取得され、スタックの先頭の値(_μs[0]_)が最初のバイトで、その後の値(_μs[1]_)が長さです。 ## H.2 命令セット {#h2-instruction-set} -EVMに関する最後のサブセクション9.5に進む前に、命令自体について考察してみましょう。 付録H.2で定義されており、ページ29から開始しています。 特定のオペコードでは、規定されていないものはすべて同じままであることが求められます。 変化する変数は、\'と規定されています。 +EVMの最後のサブセクション9.5に進む前に、命令自体を見てみましょう。 これらは付録H.2(29ページから)で定義されています。 特定のオペコードで変更されると指定されていないものはすべて、同じままであることが期待されます。 変更される変数は、\′として指定されます。 -例として、[`ADD`](https://www.evm.codes/#01)オペコードを見ていきます。 +例えば、[`ADD`](https://www.evm.codes/#01)オペコードを見てみましょう。 -| 値 | Mnemonic | δ | α | 説明 | -| ----:| -------- | - | - | --------------------------------------------------------- | -| 0x01 | ADD | 2 | 1 | 加算演算 | -| | | | | _μ′s[0] ≡ μs[0] + μs[1]_ | +| 値 | ニーモニック | δ | α | 説明 | +| ---: | ------ | - | - | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 0x01 | ADD | 2 | 1 | 加算演算 | +| | | | | _μ′s[0] ≡ μs[0] + μs[1]_ | _δ_は、スタックからポップする値の個数です。 この場合は、先頭にある2つの値を加算するので、2になります。 -_α_は、プッシュバックする値の個数です。 この場合は、合計で1になります。 +_α_は、プッシュバックする値の個数です。 この場合は合計で、1になります。 -なぜなら、新しいスタックの先頭(_μ′s[0]_)は、古いスタックの先頭(_μs[0]_)とその次の古い値(_μs[1]_)の合計となるためです。 +したがって、新しいスタックの先頭(_μ′s[0])は、古いスタックの先頭(_μs[0])とその下の古い値(_μs[1]_)の合計です。 -この記事では、すべてのオペコードを網羅するのではなく、新規性のあるオペコードのみを説明します。 +退屈なリストですべてのオペコードを確認する代わりに、この記事では何か新しいものを導入するオペコードのみを説明します。 -| 値 | Mnemonic | δ | α | 説明 | -| ----:| --------- | - | - | ---------------------------------------------------------------------------------------------------------- | -| 0x20 | KECCAK256 | 2 | 1 | Keccak-256ハッシュの計算 | -| | | | | _μ′s[0] ≡ KEC(μm[μs[0] . 。 。 (μs[0] + μs[1] − 1)])_ | -| | | | | _μ′i ≡ M(μi,μs[0],μs[1])_ | +| 値 | ニーモニック | δ | α | 説明 | +| ---: | --------- | - | - | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 0x20 | KECCAK256 | 2 | 1 | Keccak-256ハッシュの計算 | +| | | | | _μ′s[0] ≡ KEC(μm[μs[0] .. 。 。 (μs[0] + μs[1] − 1)])_ | +| | | | | _μ′i ≡ M(μi,μs[0],μs[1])_ | -これはメモリにアクセスする最初のオペコードです(この場合は、読み取り専用)。 ただし、現在のメモリの制限を超えて拡張される可能性があるため、_μi_を更新する必要があります。ページ29の式328に定義されている_M_関数を使ってこの更新を行っています。 +これはメモリにアクセスする最初のオペコードです(この場合は読み取り専用)。 ただし、現在のメモリの制限を超えて拡張される可能性があるため、_μi_を更新する必要があります。これには、29ページの式328で定義されている_M_関数を使用します。 -| 値 | Mnemonic | δ | α | 説明 | -| ----:| -------- | - | - | ---------------- | -| 0x31 | BALANCE | 1 | 1 | 指定されたアカウントの残高を取得 | -| | | | | ... | +| 値 | ニーモニック | δ | α | 説明 | +| ---: | ------- | - | - | --------------------------------------------------- | +| 0x31 | BALANCE | 1 | 1 | 指定されたアカウントの残高を取得します。 | +| | | | | ... | -残高を知る必要のあるアドレスは、_μs[0] mod 2160_ です。 スタックの最上位がアドレスなのは、アドレスは160ビットしかないためです。値を[modulo](https://en.wikipedia.org/wiki/Modulo_operation) 2160で計算します。 +残高を調べる必要のあるアドレスは_μs[0] mod 2160_です。 スタックの最上位がアドレスですが、アドレスは160ビットしかないため、値を[モジュロ](https://en.wikipedia.org/wiki/Modulo_operation)2160で計算します。 -_σ[μs[0] mod 2160] ≠ ∅_の場合、このアドレスに関する情報が存在します。 その場合、_σ[μs[0] mod 2160]b_は、そのアドレスの残高です。 _σ[μs[0] mod 2160] = ∅_ の場合、このアドレスは初期化されておらず、残高はゼロです。 アカウント情報フィールドのリストは、4ページ目のセクション4.1に記載されています。 +_σ[μs[0] mod 2160] ≠ ∅_の場合、このアドレスに関する情報が存在することを意味します。 その場合、_σ[μs[0] mod 2160]b_はそのアドレスの残高です。 _σ[μs[0] mod 2160] = ∅_の場合、このアドレスは初期化されておらず、残高はゼロであることを意味します。 アカウント情報フィールドのリストは、4ページのセクション4.1に記載されています。 -2つ目の数式、_A'a ≡ Aa ∪ \{μs[0] mod 2160}_は、ウォームストレージ(最近アクセスされ、キャッシュされる可能性が高いストレージ)とコールドストレージ(アクセスされておらず、取得コストが高く低速な可能性が高いストレージ)とのアクセスのコストの差に関連しています。 _Aa_は、トランザクションによって以前アクセスされたアドレスのリストです。このリストは、8ページ目のセクション6.1に定義されているように、アクセスするコストが安くなっています。 この件についての詳細は、[EIP-2929](https://eips.ethereum.org/EIPS/eip-2929)をご覧ください。 +2番目の式、_A'a ≡ Aa ∪ \{μs[0] mod 2160}_は、ウォームストレージ(最近アクセスされ、キャッシュされている可能性が高いストレージ)へのアクセスとコールドストレージ(アクセスされておらず、取得によりコストがかかる低速なストレージにある可能性が高いストレージ)へのアクセスのコスト差に関連しています。 _Aa_は、トランザクションによって以前にアクセスされたアドレスのリストであり、8ページのセクション6.1で定義されているように、アクセスするコストが安くなるはずです。 この主題について詳しくは、[EIP-2929](https://eips.ethereum.org/EIPS/eip-2929)で読むことができます。 -| 値 | Mnemonic | δ | α | 説明 | -| ----:| -------- | -- | -- | --------------------------------------- | -| 0x8F | DUP16 | 16 | 17 | 16番目のスタックアイテムを複製 | -| | | | | _μ′s[0] ≡ μs[15]_ | +| 値 | ニーモニック | δ | α | 説明 | +| ---: | ------ | -- | -- | ----------------------------------------------------------------------------------------------------------------------------------------------- | +| 0x8F | DUP16 | 16 | 17 | 16番目のスタックアイテムを複製します。 | +| | | | | _μ′s[0] ≡ μs[15]_ | -スタックアイテムを使用するには、ポップする必要があることに注意してください。つまり、そのアイテム上にあるすべてのスタックアイテムもポップする必要があります。 [`DUP`](https://www.evm.codes/#8f)および[`SWAP`](https://www.evm.codes/#9f)の場合は、最大で16個の値をポップして、その後にプッシュしなければならなりません。 +スタックアイテムを使用するには、それをポップする必要があることに注意してください。これは、その上にあるすべてのスタックアイテムもポップする必要があることを意味します。 [`DUP`](https://www.evm.codes/#8f)および[`SWAP`](https://www.evm.codes/#9f)の場合、これは最大16個の値をポップしてからプッシュする必要があることを意味します。 ## 9.5 実行サイクル {#95-exec-cycle} -すべてのパーツが揃ったので、ようやくEVMの実行サイクルがどのように文書化されているのかを理解できます。 +すべてのパーツが揃ったので、いよいよEVMの実行サイクルがどのように文書化されているのかを理解できます。 -数式(155)は、次の状態を示しています。 +式(155)は、次の状態が与えられたことを示しています。 -- _σ_(グローバルブロックチェーンの状態) -- _μ_(EVMの状態) -- _A_(サブ状態、トランザクション終了時に発生する変更) -- _I_(実行環境) +- _σ_(グローバルブロックチェーン状態) +- _μ_(EVM状態) +- _A_(サブ状態、トランザクション終了時に発生する変更) +- _I_(実行環境) -新たな状態は、_(σ', μ', A', I')_となります。 +新しい状態は_(σ', μ', A', I')_です。 -数式(156)~(158)は、スタックとオペコード(_μs_)によるスタックの変化を定義しています。 数式(159)は、ガスの変化(_μg_)です。 数式(160)は、プログラムカウンタ(_μpc_)の変化です。 最後に、数式(161)~(164)は、オペコードによって明示的に変更されない限り、他のパラメータが同じままであることを明記しています。 +式(156)~(158)は、スタックとオペコード(_μs_)によるスタックの変化を定義しています。 式(159)は、ガスの変化(_μg_)です。 式(160)は、プログラムカウンタ(_μpc_)の変化です。 最後に、式(161)~(164)は、オペコードによって明示的に変更されない限り、他のパラメータが同じままであることを指定しています。 -以上より、EVMが完全に定義されました。 +これにより、EVMが完全に定義されました。 -## まとめ {#conclusion} +## 結論 {#conclusion} -数学的表記法は正確であるため、イエローペーパーでは、イーサリアムのあらゆる詳細が記述されています。 ただし、次のような欠点があります。 +数学的表記法は正確であり、イエローペーパーでイーサリアムのあらゆる詳細を指定することが可能になっています。 ただし、次のような欠点があります。 -- 人間のみが理解できるため、[コンプライアンステスト](https://github.com/ethereum/tests)は、手作業によって記述する必要があります。 -- プログラマーはコンピュータのコードは理解できますが、 数学的な表記法については、理解できない人もいます。 +- 人間だけが理解できるため、[コンプライアンステスト](https://github.com/ethereum/tests)は手動で書く必要があります。 +- プログラマーはコンピュータのコードを理解します。 + しかし、数学的な表記法については理解できないかもしれません。 -このような理由から、新たな[コンセンサスレイヤーの仕様](https://github.com/ethereum/consensus-specs/blob/dev/tests/core/pyspec/README.md)は、 Pythonで記述されています。 [こちらに](https://ethereum.github.io/execution-specs)Pythonで書かれた実行レイヤーの仕様がありますが、完全ではありません。 イエローペーパー全体がPythonもしくは同様の言語に翻訳されるまで、イエローペーパーは使われ続けます。そのため、イエローペーパーを読めるようにしておくと便利です。 +おそらくこれらの理由から、新しい[コンセンサスレイヤー仕様](https://github.com/ethereum/consensus-specs/blob/dev/tests/core/pyspec/README.md)はPythonで書かれています。 [Pythonで書かれた実行レイヤー仕様](https://ethereum.github.io/execution-specs)がありますが、完全ではありません。 イエローペーパー全体がPythonまたは同様の言語に翻訳されるまで、イエローペーパーは使用され続けるため、読めるようにしておくと便利です。 diff --git a/public/content/translations/ja/eips/index.md b/public/content/translations/ja/eips/index.md index 192eabfb2cf..0db631eecd3 100644 --- a/public/content/translations/ja/eips/index.md +++ b/public/content/translations/ja/eips/index.md @@ -1,28 +1,28 @@ --- -title: イーサリアム改善提案(EIP) -description: EIPを理解するために必要な基本情報 +title: "イーサリアム改善提案(EIP)" +description: "EIPを理解するために必要な基本情報" lang: ja --- -# イーサリアム改善提案(EIP)入門 {#introduction-to-ethereum-improvement-proposals} +# イーサリアム改善提案 (EIP) の概要 {#introduction-to-ethereum-improvement-proposals} ## EIPとは {#what-are-eips} -[イーサリアム改善提案(EIP)](https://eips.ethereum.org/)は、イーサリアムの新しい機能やプロセスに関する提案を規定する標準規格です。 EIPには、技術仕様の変更案が含まれており、コミュニティの 「信頼できる情報源」として機能します。 イーサリアムのネットワークアップグレードとアプリケーションの標準規格は、EIPプロセスでの議論を通じて開発されます。 +[イーサリアム改善提案 (EIP)](https://eips.ethereum.org/) は、イーサリアムの新しい機能やプロセスに関する提案を規定する標準規格です。 EIPには、技術仕様の変更案が含まれており、コミュニティの 「信頼できる情報源」として機能します。 イーサリアムのネットワークアップグレードとアプリケーションの標準規格は、EIPプロセスでの議論を通じて開発されます。 -イーサリアムコミュニティ内の誰でもEIPを作成することができます。 EIPを書くためのガイドラインは [EIP-1](https://eips.ethereum.org/EIPS/eip-1)に記載されています。 EIPには、主に簡潔な技術仕様と提案の背景を提出する必要があります。 EIPの作成者は、コミュニティ内でコンセンサスを得て、提案に対する別の意見を文書化します。 適格なEIPを提出する上での技術的な障壁が高いため、これまでは通常アプリケーションまたはプロトコルのデベロッパーがEIPを提案しています。 +イーサリアムコミュニティ内の誰でもEIPを作成することができます。 EIP の記述に関するガイドラインは、[EIP-1](https://eips.ethereum.org/EIPS/eip-1) に含まれています。 EIPには、主に簡潔な技術仕様と提案の背景を提出する必要があります。 EIPの作成者は、コミュニティ内でコンセンサスを得て、提案に対する別の意見を文書化します。 適格なEIPを提出する上での技術的な障壁が高いため、これまでは通常アプリケーションまたはプロトコルのデベロッパーがEIPを提案しています。 ## EIPの重要性 {#why-do-eips-matter} -EIPは、イーサリアムで変更がどのように行われ、文書化されるかにおいて、中心的な役割を果たします。 EIPは変更を提案・議論し、採用する方法です。 [EIPには複数の種類](https://eips.ethereum.org/EIPS/eip-1#eip-types)があります。[EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)のようにコンセンサスに影響を与えてネットワークのアップグレードを要求する下位レベルのプロトコル変更を目的としたコアEIP、 [EIP-20](https://eips.ethereum.org/EIPS/eip-20)や[EIP-721](https://eips.ethereum.org/EIPS/eip-721)などのアプリケーション標準を目的としたERCなどがあります。 +EIPは、イーサリアムで変更がどのように行われ、文書化されるかにおいて、中心的な役割を果たします。 EIP は、人々が変更を提案し、議論し、採用するための手段です。 EIP には[さまざまな種類](https://eips.ethereum.org/EIPS/eip-1#eip-types)があり、コンセンサスに影響を与え、[EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) のようなネットワークアップグレードを必要とする低レベルのプロトコル変更のためのコア EIP や、[EIP-20](https://eips.ethereum.org/EIPS/eip-20) や [EIP-721](https://eips.ethereum.org/EIPS/eip-721) のようなアプリケーション標準のための ERC が含まれます。 -すべてのネットワークアップグレードは、複数のEIPで構成され、これらはネットワーク上の各[イーサリアムクライアント](/learn/#clients-and-nodes)に実装される必要があります。 これは、イーサリアムメインネット上の他のクライアントとコンセンサス状態を維持するには、クライアントデベロッパーは必ず必要なEIPをすべて実装しなければならないということを意味します。 +すべてのネットワークアップグレードは一連の EIP で構成されており、ネットワーク上の各[イーサリアムクライアント](/learn/#clients-and-nodes)によって実装される必要があります。 これは、イーサリアムメインネット上の他のクライアントとコンセンサス状態を維持するには、クライアントデベロッパーは必ず必要なEIPをすべて実装しなければならないということを意味します。 変更の技術仕様の提供に加えて、EIPではイーサリアムでガバナンスが行われます。誰でも自由に提案でき、コミュニティの様々な利害関係者が議論し、提案を標準規格として採用するべきか、ネットワークアップグレードに含めるべきかを判断します。 コア以外のEIPはすべてのアプリケーションで導入される必要はない一方で(例えばEIP-20を実装していない代替トークンを作成可能など)、コアEIPは広く導入されなければならず(同一ネットワークを構成するには、全ノードをアップグレードする必要があるため) 、コアEIPは非コアEIPよりもコミュニティでの広範なコンセンサスを必要とします。 -## EIPの歴史 {#history-of-eips} +## EIP の歴史 {#history-of-eips} -[イーサリアム改善提案改善提案(EIP) Githubリポジトリ](https://github.com/ethereum/EIPs)は2015年10月に作成されました。 EIPプロセスは、[Bitcoin改善提案(BIP)](https://github.com/bitcoin/bips)に基づいており、このBIP自体[Python改善提案 (PEP)](https://www.python.org/dev/peps/)に準じています。 +[イーサリアム改善提案 (EIPs) の GitHub リポジトリ](https://github.com/ethereum/EIPs)は、2015 年 10 月に作成されました。 EIP プロセスは、[Bitcoin Improvement Proposals (BIPs)](https://github.com/bitcoin/bips) プロセスに基づいており、そのプロセス自体は [Python Enhancement Proposals (PEPs)](https://www.python.org/dev/peps/) プロセスに基づいています。 EIP編集者は、技術的な健全性、フォーマットの問題、正しいスペル、文法、およびコードスタイルについてのEIPのレビューを担当します。 Martin Becze、Vitalik Buterin、Gavin Woodなど数名が、2015年から2016年まで初代のEIP編集者でした。 @@ -44,33 +44,32 @@ EIP名誉編集者は次のとおりです - Nick Savers (@nicksavers) - Vitalik Buterin (@vbuterin) -EIP編集者になりたい方は、[EIP-5069](https://eips.ethereum.org/EIPS/eip-5069)をご確認ください。 +EIP 編集者になりたい場合は、[EIP-5069](https://eips.ethereum.org/EIPS/eip-5069) を確認してください。 -EIP編集者は、提案がEIPになる準備ができているかを決定し、EIP作成者が提案を進めるのを支援します。 [イーサリアムキャットハーダーズ(Ethereum Cat Herders)](https://www.ethereumcatherders.com/)は、EIP編集者とコミュニティ間のミーティング開催をサポートします([EIPIP](https://github.com/ethereum-cat-herders/EIPIP)を参照)。 +EIP編集者は、提案がEIPになる準備ができているかを決定し、EIP作成者が提案を進めるのを支援します。 [Ethereum Cat Herders](https://www.ethereumcatherders.com/) は、EIP 編集者とコミュニティとの間の会議の開催を支援しています ([EIPIP](https://github.com/ethereum-cat-herders/EIPIP) を参照)。 -図表を含む完全な標準化プロセスは、[EIP-1](https://eips.ethereum.org/EIPS/eip-1)に記載されています。 +図表を含む完全な標準化プロセスは、[EIP-1](https://eips.ethereum.org/EIPS/eip-1) に記載されています -## 詳細 {#learn-more} +## より詳しく学ぶ {#learn-more} -EIPの詳細についてご興味がある場合は、 [EIPウェブサイト](https://eips.ethereum.org/)や[EIP-1](https://eips.ethereum.org/EIPS/eip-1)をご覧ください。 下記は役立つ情報のリンクです。 +EIP についてさらに詳しく知りたい場合は、[EIPs ウェブサイト](https://eips.ethereum.org/)と [EIP-1](https://eips.ethereum.org/EIPS/eip-1) を確認してください。 下記は役立つ情報のリンクです。 -- [全EIPのリスト](https://eips.ethereum.org/all) -- [全EIPタイプの説明](https://eips.ethereum.org/EIPS/eip-1#eip-types) -- [全EIPステータスの説明](https://eips.ethereum.org/EIPS/eip-1#eip-process) +- [すべてのイーサリアム改善提案のリスト](https://eips.ethereum.org/all) +- [すべての EIP の種類の説明](https://eips.ethereum.org/EIPS/eip-1#eip-types) +- [すべての EIP のステータスの説明](https://eips.ethereum.org/EIPS/eip-1#eip-process) ### コミュニティ教育プロジェクト {#community-projects} -- [PEEPanEIP](https://www.youtube.com/playlist?list=PL4cwHXAawZxqu0PKKyMzG_3BJV_xZTi1F) — *PEEPanEIPは、イーサリアム改善提案 (EIP) や、今後のアップグレードの主要機能について解説する教育ビデオシリーズです。* -- [EIPs For Nerds](https://ethereum2077.substack.com/t/eip-research) — *EIPs For Nerdsは、さまざまなイーサリアム改善提案 (EIP) について、ELI5スタイルの概要を提供します。これには、コアEIPやアプリケーション/インフラストラクチャ層のEIP (ERC) を含み、読者の教育やイーサリアムプロトコルの変更に対するコンセンサス形成を目的としています。* -- [EIPs.wtf](https://www.eips.wtf/) — *EIPs.wtfは、イーサリアム改善提案 (EIP) に関する追加情報を提供します。これには、EIPのステータス、実装の詳細、関連するプルリクエスト、およびコミュニティのフィードバックが含まれます。* -- [EIP.Fun](https://eipfun.substack.com/) — *EIP.Funは、イーサリアム改善提案 (EIP) に関する最新ニュース、EIP会議のアップデートなどを提供します。* -- [EIPs Insight](https://eipsinsight.com/) — *EIPs Insightは、さまざまなリソースから収集された情報に基づいて、イーサリアム改善提案 (EIP) のプロセス & 統計の現状を表しています。* +- [PEEPanEIP](https://www.youtube.com/playlist?list=PL4cwHXAawZxqu0PKKyMzG_3BJV_xZTi1F) — _PEEPanEIP は、イーサリアム改善提案 (EIPs) と、今後のアップグレードの主な機能について議論する教育ビデオシリーズです。_ +- [EIPs.wtf](https://www.eips.wtf/) — _EIPs.wtf は、イーサリアム改善提案 (EIPs) に関する追加情報を提供します。これには、ステータス、実装の詳細、関連するプルリクエスト、コミュニティからのフィードバックが含まれます。_ +- [EIP.Fun](https://eipfun.substack.com/) — _EIP.Fun は、イーサリアム改善提案 (EIPs) に関する最新ニュースや EIP 会議の更新情報などを提供します。_ +- [EIPs Insight](https://eipsinsight.com/) — _EIPs Insight は、さまざまな情報源から収集された情報に基づき、イーサリアム改善提案 (EIP) のプロセスと統計の状況を表したものです。_ -## EIPへの参加 {#participate} +## 参加 {#participate} -誰でもEIPを作成できます。 提案を提出する前に、EIPのプロセスと書き方を概説した[EIP-1](https://eips.ethereum.org/EIPS/eip-1)をお読みください。また、草案を提出する前に、まずコミュニティと議論する場所である[イーサリアム・マジシャンズ](https://ethereum-magicians.org/) でフィードバックを募ってください。 +誰でもEIPを作成できます。 提案を提出する前に、EIP のプロセスと EIP の書き方の概要が記載されている [EIP-1](https://eips.ethereum.org/EIPS/eip-1) を読み、草案を提出する前に提案がコミュニティと最初に議論される場所である [Ethereum Magicians](https://ethereum-magicians.org/) でフィードバックを求める必要があります。 -## 参考文献 {#references} +## 参考資料 {#references} diff --git a/public/content/translations/ja/energy-consumption/index.md b/public/content/translations/ja/energy-consumption/index.md index 8a5fb29f84e..2ae97ff77c6 100644 --- a/public/content/translations/ja/energy-consumption/index.md +++ b/public/content/translations/ja/energy-consumption/index.md @@ -1,14 +1,14 @@ --- -title: イーサリアムのエネルギー消費 -description: イーサリアムのエネルギー消費を理解するために必要な基本的な情報 +title: "イーサリアムのエネルギー消費" +description: "イーサリアムのエネルギー消費を理解するために必要な基本的な情報" lang: ja --- # イーサリアムのエネルギー消費 {#proof-of-stake-energy} -イーサリアムは、環境に優しいブロックチェーンです。 イーサリアムの[プルーフ・オブ・ステーク](/developers/docs/consensus-mechanisms/pos)・コンセンサスメカニズムでは、[ネットワークを保護するエネルギー](/developers/docs/consensus-mechanisms/pow)の代わりにETHを使用します。 イーサリアムのエネルギー消費量は、グローバルネットワーク全体で[年間およそ0.0026TWh](https://carbon-rateds.com/eth-report-2022)です。 +イーサリアムは、環境に優しいブロックチェーンです。 イーサリアムの[プルーフ・オブ・ステーク](/developers/docs/consensus-mechanisms/pos)コンセンサスメカニズムは、[ネットワークを保護するためのエネルギー](/developers/docs/consensus-mechanisms/pow)の代わりにETHを使用します。 イーサリアムのエネルギー消費量は、グローバルネットワーク全体で約[~0.0026 TWh/yr](https://carbon-ratings.com/eth-report-2022)です。 -このイーサリアムのエネルギー消費量の推定値は、[CCRI (Crypto Carbon Ratings Institute)](https://carbon-rateds.com)の調査を基にしています。 CCRIでは、イーサリアムネットワークの電力消費量と二酸化炭素排出量のボトムアップ方式の推定値を作成しています ([詳細はレポートをご覧ください](https://carbon-rateds.com/eth-report-2022)) 。 CCRIは、さまざまなハードウェアとクライアントソフトウェア構成の異なるノードの電力消費を測定しました。 分析時のネットワークの年間電力消費量の推定値は、**2.601 MWh** (0.0026 TWh) となり、地域別の炭素集約度係数を適用すると、年間の炭素排出量は**870トン CO2e**に相当するという結果になりました。 この値は、ノードのネットワーク入退出状況によって変化します。[ケンブリッジ・ブロックチェーン・ネットワーク・サステナビリティ・インデックス](https://ccaf.io/cbnsi/ethereum)による7日間の移動平均推定値を使って追跡することができます (推定値の算出に少し異なる方法を使っていることに注意してください。詳細はサイトをご覧ください) 。 +このイーサリアムのエネルギー消費量の推定値は、[CCRI (Crypto Carbon Ratings Institute)](https://carbon-ratings.com)の調査を基にしています。 CCRIは、イーサリアムネットワークの電力消費量と二酸化炭素排出量のボトムアップ推定値を算出しました([レポートを参照](https://carbon-ratings.com/eth-report-2022))。 CCRIは、さまざまなハードウェアとクライアントソフトウェア構成の異なるノードの電力消費を測定しました。 地域固有の炭素集約度係数を適用すると、ネットワークの年間電力消費量の推定値である**2,601 MWh** (0.0026 TWh)は、年間**870トン CO2e**の炭素排出量に相当します。 この値は、ノードがネットワークに出入りするにつれて変化します。[Cambridge Blockchain network Sustainability Index](https://ccaf.io/cbnsi/ethereum)による7日間の移動平均推定値を使用して追跡することができます(注:彼らの推定方法は若干異なり、詳細はサイトで確認できます)。 イーサリアムのエネルギー消費量の状況を把握するのに、他のいくつかの製品や業界の年間推定値で比較することできます。 この比較を通して、イーサリアムの推定値が高いのか低いのかについて、より理解することができます。 @@ -16,34 +16,34 @@ lang: ja 上のグラフでは、他のいくつかの製品や業界と比較したイーサリアムの推定年間エネルギー消費量をTWhで示しています。 提示されている推定値は、2023年7月に入手した公開情報に基づいています。以下の表に入手可能な情報源へのリンクが含まれています。 -| | 年間エネルギー消費量(TWh) | PoSイーサリアムとの比較 | 情報源 | -|:-------------- |:---------------:|:-------------:|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:| -| 世界中のデータセンター | 190 | 73,000倍 | [情報源](https://www.iea.org/commentaries/data-centres-and-energy-from-global-headlines-to-local-headaches) | -| ビットコイン | 149 | 53,000倍 | [情報源](https://ccaf.io/cbnsi/cbeci/comparisons) | -| 金の採掘 | 131 | 50,000倍 | [情報源](https://ccaf.io/cbnsi/cbeci/comparisons) | -| アメリカのゲーム業界\* | 34 | 13,000倍 | [情報源](https://www.researchgate.net/publication/336909520_Toward_Greener_Gaming_Estimating_National_Energy_Use_and_Energy_Efficiency_Potential) | -| PoWイーサリアム | 21 | 8,100倍 | [情報源](https://ccaf.io/cbnsi/ethereum/1) | -| グーグル | 19 | 7,300倍 | [情報源](https://www.gstatic.com/gumdrop/sustainability/google-2022-environmental-report.pdf) | -| Netflix | 0.457 | 176倍 | [情報源](https://assets.ctfassets.net/4cd45et68cgf/7B2bKCqkXDfHLadrjrNWD8/e44583e5b288bdf61e8bf3d7f8562884/2021_US_EN_Netflix_EnvironmentalSocialGovernanceReport-2021_Final.pdf) | -| PayPal | 0.26 | 100倍 | [情報源](https://s202.q4cdn.com/805890769/files/doc_downloads/global-impact/CDP_Climate_Change_PayPal-(1).pdf) | -| AirBnB | 0.02 | 8倍 | [情報源](https://s26.q4cdn.com/656283129/files/doc_downloads/governance_doc_updated/Airbnb-ESG-Factsheet-(Final).pdf) | -| **PoSイーサリアム** | **0.0026** | **1倍** | [情報源](https://carbon-ratings.com/eth-report-2022) | +| | 年間エネルギー消費量(TWh) | PoSイーサリアムとの比較 | 情報源 | +| :------------ | :--------------------------------: | :-----------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| 世界中のデータセンター | 190 | 73,000倍 | [出典](https://www.iea.org/commentaries/data-centres-and-energy-from-global-headlines-to-local-headaches) | +| ビットコイン | 149 | 53,000倍 | [出典](https://ccaf.io/cbnsi/cbeci/comparisons) | +| 金の採掘 | 131 | 50,000倍 | [出典](https://ccaf.io/cbnsi/cbeci/comparisons) | +| アメリカのゲーム業界\* | 34 | 13,000倍 | [出典](https://www.researchgate.net/publication/336909520_Toward_Greener_Gaming_Estimating_National_Energy_Use_and_Energy_Efficiency_Potential) | +| PoWイーサリアム | 21 | 8,100倍 | [出典](https://ccaf.io/cbnsi/ethereum/1) | +| グーグル | 19 | 7,300倍 | [出典](https://www.gstatic.com/gumdrop/sustainability/google-2022-environmental-report.pdf) | +| Netflix | 0.457 | 176倍 | [出典](https://assets.ctfassets.net/4cd45et68cgf/7B2bKCqkXDfHLadrjrNWD8/e44583e5b288bdf61e8bf3d7f8562884/2021_US_EN_Netflix_EnvironmentalSocialGovernanceReport-2021_Final.pdf) | +| PayPal | 0.26 | 100倍 | [出典](https://s202.q4cdn.com/805890769/files/doc_downloads/global-impact/CDP_Climate_Change_PayPal-\(1\).pdf) | +| AirBnB | 0.02 | 8倍 | [出典](https://s26.q4cdn.com/656283129/files/doc_downloads/governance_doc_updated/Airbnb-ESG-Factsheet-\(Final\).pdf) | +| **PoSイーサリアム** | **0.0026** | **1x** | [出典](https://carbon-ratings.com/eth-report-2022) | \*PC、ラップトップ、ゲーム端末などのエンドユーザーデバイスも含まれています。 -エネルギー消費量の正確な推定値を把握することは難しく、特に測定される対象が複雑なサプライチェーンを持っているか、効率に影響を及ぼすデプロイメントに関する詳細を含んでいる場合は、より困難になります。 例えば、NetflixとGoogleのエネルギー消費量の推定値は、システムの維持に使われるエネルギーおよびコンテンツをユーザに配信するエネルギー (_直接支出_) 、または、コンテンツの制作、事務所の運営、広告などに必要な支出に使われるエネルギー (_間接支出_) が含まれるかどうかにより異なります。 間接支出には、テレビ、コンピュータ、携帯端末などのエンドユーザーデバイスがコンテンツを消費するのに要するエネルギーとして含まれる場合があります。 +エネルギー消費量の正確な推定値を把握することは難しく、特に測定される対象が複雑なサプライチェーンを持っているか、効率に影響を及ぼすデプロイメントに関する詳細を含んでいる場合は、より困難になります。 例えば、NetflixとGoogleのエネルギー消費量の推定値は、システムの維持とユーザーへのコンテンツ配信に使用されるエネルギー(_直接支出_)のみを含むか、コンテンツ制作、オフィス運営、広告などに必要な支出を含むか(_間接支出_)によって異なります。 間接支出には、テレビ、コンピュータ、携帯端末などのエンドユーザーデバイスがコンテンツを消費するのに要するエネルギーとして含まれる場合があります。 上記の推定値は、完全に正確な比較ではありません。 計上される間接支出の額は、情報源によって異なりますし、エンドユーザーデバイスからのエネルギーが含まれることはほとんどありません。 裏付けとなっている各情報源には、測定対象に関する詳細が含まれています。 -上の表とグラフには、ビットコインとプルーフ・オブ・ワークでのイーサリアムとの比較も含まれています。 プルーフ・オブ・ワークのネットワークのエネルギー消費量は、静的ではなく、日々変化することに注意することが重要です。 また、推定値は情報源によって大きく異なる場合もあります。 このトピックは、 エネルギー消費量だけでなく、そのエネルギー源とそれに関連する倫理について、ちょっとした[議論](https://www.coindesk.com/business/2020/05/19/the-last-word-on-bitcoins-energy-consumption/)を巻き起こします。 エネルギー消費量は、必ずしも環境フットプリントに正確に対応するわけではありません。なぜなら、プロジェクトによって、再生可能エネルギーの割合が少なかったり多かったりするなど、使用するエネルギー源が異なる可能性があるからです。 例えば、[ケンブリッジビットコイン電力消費インデックス](https://ccaf.io/cbnsi/cbeci/comparisons)では、ビットコインのネットワーク需要が理論的にガスフレアや送電・配電で失われる電力で賄えることを示しています。 イーサリアムのサステナビリティへの工程は、エネルギーの大量消費をしている箇所を環境に優しい代替手段に置き換えることでした。 +上の表とグラフには、ビットコインとプルーフ・オブ・ワークでのイーサリアムとの比較も含まれています。 プルーフ・オブ・ワークのネットワークのエネルギー消費量は、静的ではなく、日々変化することに注意することが重要です。 また、推定値は情報源によって大きく異なる場合もあります。 このトピックは、消費されるエネルギー量だけでなく、そのエネルギー源や関連する倫理についても、微妙なニュアンスを含む[議論](https://www.coindesk.com/business/2020/05/19/the-last-word-on-bitcoins-energy-consumption/)を呼んでいます。 エネルギー消費量は、必ずしも環境フットプリントに正確に対応するわけではありません。なぜなら、プロジェクトによって、再生可能エネルギーの割合が少なかったり多かったりするなど、使用するエネルギー源が異なる可能性があるからです。 例えば、[Cambridge Bitcoin Electricity Consumption Index](https://ccaf.io/cbnsi/cbeci/comparisons)は、ビットコインネットワークの需要が理論的にガスフレアや送電・配電で失われる電力で賄えることを示しています。 イーサリアムのサステナビリティへの工程は、エネルギーの大量消費をしている箇所を環境に優しい代替手段に置き換えることでした。 -[ケンブリッジ・ブロックチェーン・ネットワーク・サステナビリティ・インデックスのサイト](https://ccaf.io/cbnsi/ethereum)で、さまざまな業界のエネルギー消費量と二酸化炭素排出量の推定値を参照することができます。 +多くの業界のエネルギー消費量と炭素排出量の推定値は、[Cambridge Blockchain Network Sustainability Indexのサイト](https://ccaf.io/cbnsi/ethereum)で閲覧できます。 ## トランザクションごとの推定値 {#per-transaction-estimates} 多くの記事では、ブロックチェーンの「トランザクションごと」のエネルギー消費量を推定しています。 ブロックを提案、検証するために必要なエネルギーはブロック内のトランザクション数とは無関係のため、誤解を招く可能性があります。 トランザクション単位でエネルギー消費量を試算すると、トランザクション数が少なければエネルギー消費量も少なくなり、その逆もしかりということになりますが、実際はそうではありません。 また、トランザクションごとの推定値は、ブロックチェーンのトランザクションスループットの定義に非常に敏感であり、この定義を微調整することで、値を大きくしたり小さくしたりすることができます。 -例えば、イーサリアムでは、トランザクションのスループットはベースレイヤーのものだけでなく、「[レイヤー 2](/layer-2/)」のロールアップで行われたトランザクションスループット全ての合計です。 通常、レイヤー2は計算に含まれませんが、シーケンサーが消費する追加エネルギー(小)と、シーケンサーが処理するトランザクション数(大)を考慮すると、トランザクションごとの推定値が大幅に減少する可能性があります。 これが、プラットフォーム間のトランザクションごとのエネルギー消費量の比較が誤解を招きかねない理由の1つです。 +例えばイーサリアムでは、トランザクションスループットはベースレイヤーのものだけでなく、そのすべての「[レイヤー2](/layer-2/)」ロールアップのトランザクションスループットの合計でもあります。 通常、レイヤー2は計算に含まれませんが、シーケンサーが消費する追加エネルギー(小)と、シーケンサーが処理するトランザクション数(大)を考慮すると、トランザクションごとの推定値が大幅に減少する可能性があります。 これが、プラットフォーム間のトランザクションごとのエネルギー消費量の比較が誤解を招きかねない理由の1つです。 ## イーサリアムの炭素負債 {#carbon-debt} @@ -51,15 +51,15 @@ lang: ja 当初から、プルーフ・オブ・ステークに基づく合意メカニズムの実装を計画していましたが、安全性と分散化を損なうことなく実現するためには、集中的な研究開発に数年を要しました。 こうした背景から、まずはネットワークを開始するために、プルーフ・オブ・ワークのメカニズムが採用されたのです。 プルーフ・オブ・ワークは、マイナーが自分のハードウェアを使って値を計算する必要があり、その過程でエネルギーを消費します。 - + -CCRIによる推定では、マージによってイーサリアムの年間電力消費量が**99.988%**以上削減されたと算出されています。 同様に、イーサリアムの二酸化炭素排出量も約**99.992%**削減しました(11,016,000トンCO2eから870トンCO2eへ削減) 。 この排出量の削減を比較して考えると、上の図に示されているように、エッフェル塔の高さから小さなプラスチック製のおもちゃのフィギュアに変わるようなものです。 結果として、ネットワークの安全性を確保するための環境負荷は大幅に軽減されました。 これと同時にネットワークのセキュリティも向上したとされています。 +CCRIは、マージによってイーサリアムの年間電力消費量が\*\*99.988%**以上削減されたと推定しています。 同様に、イーサリアムの炭素フットプリントは約**99.992%\*\*削減されました(11,016,000トンCO2eから870トンCO2eへ)。 この排出量の削減を比較して考えると、上の図に示されているように、エッフェル塔の高さから小さなプラスチック製のおもちゃのフィギュアに変わるようなものです。 結果として、ネットワークの安全性を確保するための環境負荷は大幅に軽減されました。 これと同時にネットワークのセキュリティも向上したとされています。 -## 環境にやさしいアプリケーションレイヤー {#green-applications} +## グリーンなアプリケーションレイヤー {#green-applications} -イーサリアムのエネルギー消費量が非常に少ない一方で、イーサリアム上で[**再生金融(ReFi)**](/refi/)コミュニティも構築され、大きく成長し、活発化しています。 再生金融(ReFi)アプリケーションは、分散型金融(DeFi)コンポーネントを使用して、環境にプラスとなるような外部性をもたらす金融アプリケーションを構築します。 再生金融(ReFi)は、イーサリアムと密接に連携し、技術の進歩と環境保全の両立を目指す[「Solarpunk」](https://en.wikipedia.org/wiki/Solarpunk)運動の一翼を担っています。 イーサリアムが分散型かつ自由参加型で、構成可能であるため、再生金融(ReFi)やソーラーパンクコミュニティの理想的なベースレイヤーとなっています。 +イーサリアムのエネルギー消費量は非常に低いですが、イーサリアムを基盤として構築している、大規模で成長著しく、非常に活発な[**再生金融(ReFi)**](/refi/)コミュニティも存在します。 再生金融(ReFi)アプリケーションは、分散型金融(DeFi)コンポーネントを使って、環境にプラスとなるような外部性をもたらす金融アプリケーションを構築します。 再生金融(ReFi)は、イーサリアムと密接に連携し、技術の進歩と環境保全の両立を目指す、より広範な[「solarpunk」](https://en.wikipedia.org/wiki/Solarpunk)ムーブメントの一翼を担っています。 イーサリアムが分散型かつ自由参加型で、構成可能であるため、再生金融(ReFi)やソーラーパンクコミュニティの理想的なベースレイヤーとなっています。 -[Gitcoin](https://gitcoin.co)のようなWeb3ネイティブの公共財資金調達プラットフォームは、イーサリアムのアプリケーションレイヤー上で環境に配慮した構築を促進するために気候ラウンドを実行します。 これらの開発(例:[DeSci](/desci/)など)を通じて、イーサリアムは環境的にも社会的にもネットポジティブな技術になりつつあります。 +[Gitcoin](https://gitcoin.co)のようなWeb3ネイティブの公共財資金調達プラットフォームは、イーサリアムのアプリケーションレイヤー上で環境に配慮した構築を促進するために、気候ラウンドを実施しています。 これらのイニシアチブ(および[DeSci](/desci/)などのその他)の発展を通じて、イーサリアムは環境的にも社会的にもネットポジティブなテクノロジーになりつつあります。 @@ -70,18 +70,17 @@ CCRIによる推定では、マージによってイーサリアムの年間電 -## 参考文献 {#further-reading} +## 参考リンク {#further-reading} - [ケンブリッジ・ブロックチェーン・ネットワーク・サステナビリティ・インデックス](https://ccaf.io/cbnsi/ethereum) -- [プルーフオブワークのブロックチェーンに関するホワイトハウス報告書](https://web.archive.org/web/20221109005700/https://www.whitehouse.gov/wp-content/uploads/2022/09/09-2022-Crypto-Assets-and-Climate-Report.pdf) -- [イーサリアムの二酸化炭素排出量: ボトムアップ推定値](https://kylemcdonald.github.io/ethereum-emissions/) – _Kyle McDonald_ -- [イーサリアムエネルギー消費量インデックス](https://digiconomist.net/ethereum-energy-consumption/) - _Digiconomist_ +- [プルーフ・オブ・ワーク・ブロックチェーンに関するホワイトハウス報告書](https://web.archive.org/web/20221109005700/https://www.whitehouse.gov/wp-content/uploads/2022/09/09-2022-Crypto-Assets-and-Climate-Report.pdf) +- [イーサリアムの排出量:ボトムアップ推定](https://kylemcdonald.github.io/ethereum-emissions/) - _Kyle McDonald_ +- [イーサリアム・エネルギー消費インデックス](https://digiconomist.net/ethereum-energy-consumption/) - _Digiconomist_ - [ETHMerge.com](https://ethmerge.com/) - _[@InsideTheSim](https://twitter.com/InsideTheSim)_ -- [マージ - イーサリアムネットワークの電力消費量と二酸化炭素排出量への影響](https://carbon-ratings.com/eth-report-2022) - _CCRI_ +- [マージ - イーサリアムネットワークの電力消費と炭素フットプリントへの影響](https://carbon-ratings.com/eth-report-2022) - _CCRI_ - [イーサリアムのエネルギー消費](https://mirror.xyz/jmcook.eth/ODpCLtO4Kq7SCVFbU4He8o8kXs418ZZDTj0lpYlZkR8) ## 関連トピック {#related-topics} -- [イーサリアムのビジョン](/roadmap/vision/) - [ビーコンチェーン](/roadmap/beacon-chain) - [マージ](/roadmap/merge/) diff --git a/public/content/translations/ja/eth/supply/index.md b/public/content/translations/ja/eth/supply/index.md new file mode 100644 index 00000000000..01d294adf8b --- /dev/null +++ b/public/content/translations/ja/eth/supply/index.md @@ -0,0 +1,80 @@ +--- +title: "ETHの供給と発行の理解" +description: "ETHの供給と発行に関する初心者向けのガイドで、EIP、PoS、EIP-1559などの主要な概念を網羅しています。" +lang: ja +--- + +# ETHの供給と発行 {#eth-supply-and-issuance} + +## 前提条件 {#prerequisites} + +この文書は、事前の知識がない初心者向けに書かれています。 ただし、このトピックを完全に理解するには、[イーサリアム改善提案 (EIPs)](/eips/#introduction-to-ethereum-improvement-proposals)、[プルーフ・オブ・ワーク (PoW)](/developers/docs/consensus-mechanisms/pow/)、[プルーフ・オブ・ステーク (PoS)](/developers/docs/consensus-mechanisms/pos/)、[ロンドンアップグレード](/ethereum-forks/#london)などの概念について基本的な理解があると役立ちます。 + +## 現在、イーサリアムトークンはどれくらい存在しますか? {#current-eth-supply} + +ETHの総供給量は動的であり、主に2つの要因により常に変化しています: + +1. **プルーフ・オブ・ステーク(PoS)による発行**:ネットワークを保護するバリデーターへの報酬として、新しいETHが作成されます +2. **EIP-1559によるバーン**:取引手数料の一部が流通から永久に削除されます + +これらの現在の供給量と変化は、 [Ultrasound Money](https://ultrasound.money)のようなプラットフォームでリアルタイムに追跡できます。 + +イーサリアムの供給量と発行量は、ネットワークの健全性と将来を理解するための不可欠な指標です。 しかし、ETHの発行とは一体何を意味するのでしょうか? これを詳しく見ていきましょう。 + +## ETHの供給と発行が重要である理由 {#why-eth-supply-matters} + +従来の金融では、中央銀行が通貨の供給量を管理し、経済を刺激するためにより多くのお金を印刷することがよくあります。 一方、イーサリアムは、そのコードによって管理される透明で予測可能なシステムで動作します。 新しいETHがどれくらいの速さで発行されるかを知ることは、以下の点に役立ちます: + +- **信頼を構築する**:イーサリアムコミュニティは、ブロックチェーンから直接供給量と発行量のデータを検証できます。 +- **価値を理解する**:発行量とETHのバーン率の関係は、ETHのインフレまたはデフレに影響を与え、時間の経過とともにその価値に影響を与えます。 +- **ネットワークの健全性を追跡する**:発行量とバーン率の変化は、ネットワークのアクティビティとセキュリティを反映しています。 + +## ETHの発行とは? {#eth-issuance} + +ETHの発行とは、イーサリアムネットワークを保護するバリデーターへの報酬として、新しいETHが作成されるプロセスのことです。 それはETHの総流通量である総供給量とは異なります。 + +### 簡単に言うと、以下のようになります: + +- **発行**は、ネットワークに新しいETHを追加します。 +- **焼却**は(EIP-1559によって導入され)、取引手数料の一部を破壊することで、ネットワークからETHを削除します。 + +これら2つの力によって、イーサリアムの供給量が時間の経過とともに増加(インフレ的)するか、減少(デフレ的)するかが決まります。 + +## ETHの供給と発行 {#eth-supply-today} + +イーサリアムのプルーフ・オブ・ステーク(PoS)システムは、以前のプルーフ・オブ・ワーク(PoW)モデルと比較して、ETHの発行量を大幅に削減しました。 バリデーターは、ネットワークを保護するためにETHをロックアップし、その報酬としてETHを獲得します。 現在の発行レートは [Ultrasound Money](https://ultrasound.money)で確認できます。 + +しかし、この数値は動的です。 EIP-1559のおかげで、ネットワーク活動が高い場合、ETHのバーンレートは発行量を上回り、デフレ効果を生み出します。 例えば、NFTのローンチやDeFi活動のような需要が高い時期には、発行されるETHよりも多くのETHがバーンされることがあります。 + +### ETHの供給量と発行量を追跡するためのツールは以下の通りです: + +- [Ultrasound Money](https://ultrasound.money) - ETHの供給量、発行量、バーンレートをリアルタイムで追跡できます +- [Etherscan](https://etherscan.io) - 供給量メトリクスを持つブロックエクスプローラー + +## 将来のETHの供給と発行に影響を与える要因 {#future-eth-supply} + +イーサリアムの将来の供給量は固定されていません。それはいくつかの変数に依存します: + +1. **ステーキングへの参加**: + - ネットワークに参加するバリデーターが増えるということは、より多くのETH報酬が分配されることを意味します。 + - 参加するバリデーターが減ると、発行量が減少する可能性があります。 + - [staking](/staking/)の詳細についてはこちらをご覧ください。 + +2. **ネットワーク活動**: + - 高い取引量により、より多くのETHがバーンされ、発行量を相殺または上回る可能性があります。 + - [gas fees](/developers/docs/gas/) とそれがバーンに与える影響についてお読みください。 + +3. **プロトコルのアップグレード**: + - イーサリアムのコードへの将来の変更は、ステーキング報酬やバーンメカニズムを調整し、供給の動態をさらに形成する可能性があります。 + - [Ethereum roadmap](/roadmap/)で最新情報を入手しましょう。 + +## まとめ:ETHの供給、発行、そして次に来るもの {#recap} + +ETHの供給と発行に関して知っておくべきことの簡単な要約は以下の通りです: + +- **ETH供給量**:[Ultrasound Money](https://ultrasound.money)のようなツールを通じてリアルタイムで追跡可能な、動的で常に変化しています +- **PoS下の発行**:PoWと比較して大幅に削減され、報酬はバリデーターに分配されます。 [Ultrasound Money](https://ultrasound.money)で現在のレートを確認してください +- **EIP-1559の役割**:ネットワーク活動が高い期間中、ETHのバーンによりネットワークがデフレになる可能性があります +- **将来の傾向**:ステーキングへの参加、ネットワーク需要、およびプロトコルのアップデートがすべてETHの供給量を形成するでしょう + +ETHの発行を理解することは、イーサリアムの価値とそのデフレ的で分散化された資産としての可能性を明確にするのに役立ちます。 The MergeがETH供給にどのように影響したかについてのより詳細な情報については、[詳細な分析](/roadmap/merge/issuance/)をご覧ください。 ETHの将来について知りたいですか? [Ultrasound Money](https://ultrasound.money)のようなツールで深く掘り下げたり、[ステーキングガイド](/staking/)を探索したりしてください。 \ No newline at end of file diff --git a/public/content/translations/ja/ethereum-forks/index.md b/public/content/translations/ja/ethereum-forks/index.md index 4efd9f7e901..b9e71c30548 100644 --- a/public/content/translations/ja/ethereum-forks/index.md +++ b/public/content/translations/ja/ethereum-forks/index.md @@ -1,233 +1,399 @@ --- -title: イーサリアムの歴史とフォーク -description: 主要なマイルストーン、リリース、フォークを含むイーサリアムブロックチェーンの歴史。 +title: "全イーサリアムフォークのタイムライン(2014年~現在)" +description: "主要なマイルストーン、リリース、フォークを含むイーサリアムブロックチェーンの歴史。" lang: ja sidebarDepth: 1 --- -# イーサリアムの歴史 {#the-history-of-ethereum} +# 全イーサリアムフォークのタイムライン(2014年~現在) {#the-history-of-ethereum} イーサリアムブロックチェーンの主要なマイルストーン、フォーク、アップデートをすべてまとめたタイムラインです。 - + -フォークとは、ネットワークに必要となる大規模な技術アップグレードや変更のことで、通常は[イーサリアム改善提案 (EIPs)](/eips/)に基づいて、プロトコルの「規約」を変更するものです。 +フォークとは、ネットワークに必要となる大規模な技術アップグレードや変更のことで、通常は[イーサリアム改善提案 (EIPs) ](/eips/)に基づいて、プロトコルの「規約」を変更するものです。 -従来の中央集権型のソフトウェアにおいてアップグレードが必要になった場合、企業はエンドユーザのために新バージョンを公開します。 中央集権型の所有権がないブロックチェーンでは、仕組みが異なります。 [イーサリアムクライアント](/developers/docs/nodes-and-clients/)が新しいフォークルールを実装するには、ソフトウェアのアップデートが必要となります。 さらに、ブロック作成者(プルーフ・オブ・ワークの世界ではマイナー、プルーフ・オブ・ステークの世界ではバリデータ)とノードは、ブロックを作成し、新しいルールに照らし合わせて検証しなければなりません。 [合意メカニズムの詳細](/developers/docs/consensus-mechanisms/) +従来の中央集権型のソフトウェアにおいてアップグレードが必要になった場合、企業はエンドユーザのために新バージョンを公開します。 中央集権型の所有権がないブロックチェーンでは、仕組みが異なります。 [イーサリアムクライアント](/developers/docs/nodes-and-clients/)が新しいフォークルールを実装するには、ソフトウェアのアップデートが必要となります。 さらに、ブロック作成者(プルーフ・オブ・ワークの世界ではマイナー、プルーフ・オブ・ステークの世界ではバリデータ)とノードは、ブロックを作成し、新しいルールに照らし合わせて検証しなければなりません。 [コンセンサスメカニズムに関する詳細](/developers/docs/consensus-mechanisms/) -これらのルール変更により、ネットワークに一時的な分断が生じる可能性があります。 新規ブロックは、新しいルールもしくは古いルールに基づいて生成できます。 フォークは事前に合意されることが一般的で、クライアントが一斉に変更を採用し、アップグレードされたフォークがメインチェーンとなります。 しかし、まれにフォークをめぐる意見の相違により、ネットワークが永久に分断してしまうことがあります。最も有名な例は、[DAO フォーク](#dao-fork)によるイーサリアムクラシックの誕生です。 +これらのルール変更は、ネットワークに一時的な分裂を生じさせる可能性があります。 新規ブロックは、新しいルールもしくは古いルールに基づいて生成できます。 フォークは事前に合意されることが一般的で、クライアントが一斉に変更を採用し、アップグレードされたフォークがメインチェーンとなります。 しかし、まれにフォークをめぐる意見の相違がネットワークの永久的な分裂を引き起こしてしまうことがあります。もっとも有名な例が、DAOフォークによるEthereum Classicの誕生です。 -[ビーコンチェーン](/upgrades/beacon-chain/)、[マージ](/upgrades/merge/)、[EIP-1559](#london)から過去の重要なアップグレードをご確認ください。 + -今後のプロトコルアップグレードについては、 [イーサリアムロードマップ上の今後のアップグレードについて](/roadmap/)をご参照ください。 +Ethereumの基礎となるソフトウェアは二つに分けることができ、片方は[実行レイヤー](/glossary/#execution-layer)、もう片方は[コンセンサスレイヤー](/glossary/#consensus-layer) として知られています。 + +**実行アップグレードの命名** + +2021年以降、**実行レイヤー**へのアップグレードは、過去の[Devcon開催地](https://devcon.org/en/past-events/)の都市名にちなんで時系列で命名されています: + +| アップグレード名 | Devcon開催年 | Devcon番号 | アップグレード日 | +| ---------- | --------- | -------- | ---------- | +| ベルリン | 2014年 | 0 | 2021年4月15日 | +| ロンドン | 2015年 | I | 2021年8月5日 | +| Shanghai | 2016年 | II | 2023年4月12日 | +| Cancun | 2017年 | III | 2024年3月13日 | +| **Prague** | 2018 | IV | 未定 - 次回 | +| _Osaka_ | 2019年 | V | 未定 | +| _Bogota_ | 2022年 | VI | 未定 | +| _Bangkok_ | 2024年 | VII | 未定 | + +**コンセンサスアップグレードの命名** + +[ビーコンチェーン](/glossary/#beacon-chain)のローンチ以来、**コンセンサスレイヤー**へのアップグレードは、アルファベット順に進む文字で始まる天体の星にちなんで命名されています: + +| アップグレード名 | アップグレード日 | +| ------------------------------------------------------------- | ----------- | +| ビーコンチェーンの誕生 | 2020年12月1日 | +| [Altair](https://en.wikipedia.org/wiki/Altair) | 2021年10月27日 | +| [Bellatrix](https://en.wikipedia.org/wiki/Bellatrix) | 2022年9月6日 | +| [Capella](https://en.wikipedia.org/wiki/Capella) | 2023年4月12日 | +| [Deneb](https://en.wikipedia.org/wiki/Deneb) | 2024年3月13日 | +| [**Electra**](https://en.wikipedia.org/wiki/Electra_\(star\)) | 未定 - 次回 | +| [_Fulu_](https://en.wikipedia.org/wiki/Fulu_\(star\)) | 未定 | + +**結合された命名** + +実行アップグレードとコンセンサスアップグレードは当初、異なる時期に展開されていましたが、2022年の[The Merge](/roadmap/merge/)以降は同時にデプロイされています。 そのため、簡単に1つに連結した用語を使用してアップグレードを参照できるように俗称が登場しました。 これは、一般に「シャペラ」と呼ばれる 上海-カペラ アップグレードから始まり、続いて カンクン-デネブ(デンクン)、そして プラハ-エレクトラ(ペクトラ) へと続く一連のアップグレードです。 + +| 実行アップグレード | コンセンサスアップグレード | 短縮名 | +| --------- | ------------- | ---------- | +| Shanghai | Capella | "Shapella" | +| Cancun | Deneb | "Dencun" | +| Prague | Electra | "Pectra" | +| Osaka | Fulu | "Fusaka" | + + +特に重要な過去のアップグレードに関する情報に直接移動する:[The Beacon Chain](/roadmap/beacon-chain/)、[The Merge](/roadmap/merge/)、[EIP-1559](#london) + +今後のプロトコルアップグレードについては、 [イーサリアムのロードマップ上の今後のアップグレードについて学ぶ](/roadmap/) -## 2023 年 {#2023} +## 2025 {#2025} + +### Fulu-Osaka(「Fusaka」) {#fusaka} + + + +[Fusakaに関する詳細](/roadmap/fusaka/) + +### Prague-Electra (「Pectra」) {#pectra} + + -### 上海(_予定_) {#shanghai} +プラハ‐エレクトラ(「ペクトラ」)アップグレードには、すべてのユーザー、レイヤー2ネットワーク、ステーカー、ノードオペレーターの体験を向上させることを目的とした、イーサリアムプロトコルのいくつかの改良が含まれていました。 -タイムスタンプ: Apr-12-2023 22:27:35 +UTC ブロック番号: TBD ETH 価格: TBD +ステーキング機能が強化され、複利運用が可能なバリデータアカウントが導入されたほか、実行層の出金アドレスを使ってステークした資金をより柔軟に管理できるようになりました。 EIP-7251により、1つのバリデータの最大有効残高が2048まで引き上げられ、ステーカーの資本効率が向上しました。 EIP-7002により、実行アカウントが安全にバリデータの操作(退出や一部資金の出金など)を実行できるようになり、ETHステーカーの利便性が向上するとともに、ノードオペレーターの責任性強化にもつながりました。 -#### 要約 {#shanghai-summary} +アップグレードのほかの部分では、一般ユーザーの利便性向上にも重点が置かれました。 EIP-7702は、通常のスマートコントラクトではないアカウント([EOA](/glossary/#eoa))がスマートコントラクトと同様のコードを実行できる機能をもたらしました。 これにより、従来のイーサリアムアカウントにおいて、トランザクションのバッチ処理、ガス代の代行支払い、代替的な認証方法、支出のプログラム制御、アカウント復旧機構など、制限のない新たな機能が利用可能になりました。 -上海アップグレードにより、実行レイヤーへのステーキングの引き出しが可能になります。 カペラのアップグレードと並行して、ブロックは引き出し操作を受け付けられるようになり、ステーカーはビーコンチェーンから実行レイヤーに ETH を引き出せるようになります。 + - +ユーザー体験の向上: -- [EIP-3651](https://eips.ethereum.org/EIPS/eip-3651) – 「COINBASE」アドレスウォームを開始 -- [EIP-3855](https://eips.ethereum.org/EIPS/eip-3855) – 新しい「PUSH0」命令 -- [EIP-3860](https://eips.ethereum.org/EIPS/eip-3860) – リミットとメーターの初期コード -- [EIP-4895](https://eips.ethereum.org/EIPS/eip-4895) – 操作としてのビーコンチェーンのプッシュの引き出し -- [EIP-6049](https://eips.ethereum.org/EIPS/eip-6049) – `SELFDESTRUCT`の廃止 + + EIP-7702 - EOAアカウントにコードを設定 + EIP-7691 - ブロブ処理能力の向上 + EIP-7623 - コールデータのコスト引き上げ + EIP-7840 - 実行レイヤー(EL)の設定ファイルにブロブスケジュールを追加 + +ステーキング体験の向上: + + + EIP-7251 - MAX_EFFECTIVE_BALANCE の上限を引き上げ + EIP-7002 - 実行レイヤーからトリガー可能な退出機能 + EIP-7685 - 汎用的な実行レイヤーリクエスト + EIP-6110 - オンチェーンでのバリデータ入金処理 + + +プロトコルの効率性とセキュリティの向上: + + + EIP-2537 - BLS12-381曲線演算のためのプリコンパイル追加 + EIP-2935 - ステートに過去のブロックハッシュを保存 + EIP-7549 - committee indexを署名付きアテステーションの外部へ移動 + -- [上海のアップグレード仕様を読む](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/shanghai.md) +- [Pectra.wtf](https://pectra.wtf) +- [Pectraがステーキング体験を向上させる方法](https://www.kiln.fi/post/next-ethereum-upgrade-how-pectra-will-enhance-the-staking-experience) +- [Electraアップグレードの仕様を読む](https://github.com/ethereum/consensus-specs/blob/dev/specs/electra/) +- [Prague-Electra(「Pectra」) FAQ](/roadmap/pectra/) ---- + -### カペラ(_予定_) {#capella} +## 2024 {#2024} -タイムスタンプ: Apr-12-2023 22:27:35 +UTC エポック番号: 194048(スロット 6209536) ETH 価格: TBD +### Cancun-Deneb(「Dencun」) {#dencun} -#### 要約 {#capella-summary} + -カペラのアップグレードは、コンセンサスレイヤー(ビーコンチェーン)に対する 3 番目の主要なアップグレードであり、ステーキングの引き出しが可能になります。 カペラは、実行レイヤーで行われる上海のアップグレードと同時に行われ、お互いに同期して引き出し機能を有効にします。 +#### Cancunの概要 {#cancun-summary} -このコンセンサスレイヤーのアップグレードにより、最初の入金で引き出し認証情報を提供しなかったステーカーによる引き出しが可能になります。 +Cancunアップグレードには、Denebのコンセンサスアップグレードと連携してスケーラビリティの向上を目指す、イーサリアムの_実行_に対する一連の改善が含まれています。 + +特に、**Proto-Danksharding**として知られるEIP-4844が含まれており、これによりレイヤー2ロールアップのデータストレージコストが大幅に削減されます。 これは、ロールアップがメインネットに対してデータを短い期間投稿できるようにする、「ブロブ」というデータを導入することにより実現します。 これにより、レイヤー2ロールアップのトランザクションフィーが大幅に低下します。 + + + + + EIP-1153 - 一時的なストレージオペコード + EIP-4788 - EVMのビーコンブロックルート + EIP-4844 - シャード・ブロブ・トランザクション(プロト・ダンクシャーディング) + EIP-5656 - MCOPY -メモリコピー命令 + EIP-6780 - SELFDESTRUCTの使用を同一のトランザクションに制限 + EIP-7516 - オペコードBLOBBASEFEE + + -また、このアップグレードによって、自動アカウントスイープ機能も実装されるため、バリデータアカウントを継続的に処理し、報酬の支払いや全額引き出しができるようになります。 +- [レイヤー2ロールアップ](/layer-2/) +- [Proto-Danksharding](/roadmap/scaling/#proto-danksharding) +- [Danksharding](/roadmap/danksharding/) +- [Cancunアップグレードの仕様を読む](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/cancun.md) -- [ステーキングの引き出しについての詳細](/staking/withdrawals/) -- [カペラのアップグレード仕様を読む](https://github.com/ethereum/consensus-specs/blob/dev/specs/capella/) +#### Denebの概要 {#deneb-summary} + +Denebアップグレードには、スケーラビリティの向上を目的としたイーサリアムの_コンセンサス_に対する一連の改善が含まれています。 このアップグレードは、カンクン実行レイヤーアップグレードと並行して行われ、プロトダンクシャーディング(EIP-4844)を可能にし、他のビーコンチェーンの改善策も含まれます。 + +事前に生成された署名付きの「自発的退出メッセージ」に有効期限がなくなり、サードパーティーのノードオペレータに資金をステーキングしているユーザーによるコントロールが強化されました。 この署名付きの退出メッセージにより、ステーカーはノードの運用を他者に委任しつつも、誰の許可も得ることなく、いつでも安全に退出して資金を引き出すことができるようになります。 + +EIP-7514では、バリデータがネットワークに参加できる「チャーン」レートをエポックあたり8に制限することにより、ETHの発行を引き締めます。 ETHの発行はステーキングされたETHの総量に比例するため、参加するバリデータの数を制限することで、新たに発行されるETHの_増加率_に上限が設けられ、同時にノードオペレーターのハードウェア要件も削減され、分散化が促進されます。 + + + + + EIP-4788 - EVMのビーコンブロックルート + EIP-4844 - シャード・ブロブ・トランザクション + EIP-7044 - 永続的に有効な署名付きの自発的退出 + EIP-7045 - 認証スロットの最大アテステーションを拡張 + EIP-7514 - チャーンの最大エポック数の制限 + + + +- [Denebアップグレードの仕様を読む](https://github.com/ethereum/consensus-specs/blob/dev/specs/deneb/) +- [Cancun-Deneb(「Dencun」) FAQ](/roadmap/dencun/) -## 2022 年 {#2022} +## 2023 {#2023} -### パリ(マージ) {#paris} +### Shanghai-Capella(「Shapella」) {#shapella} -Sep-15-2022 06:42:42 AM +UTC ブロック番号: 15537394 ETH 価格: $1,472 USD waybackmachine 上の ethereum.org + -#### 要約 {#paris-summary} +#### Shanghaiの概要 {#shanghai-summary} -パリのアップグレードは、58750000000000000000000 の[最終合計難易度](/glossary/#terminal-total-difficulty)に到達した時点でプルーフ・オブ・ワークのブロックチェーンによってトリガーされました。 2022 年 9 月 15 日にブロック 15537393 で発生し、次のブロックでパリのアップグレードがトリガーされたものです。 パリは、[マージ](/upgrades/merge/)への移行でした。主要な変更は、[プルーフ・オブ・ワーク](/developers/docs/consensus-mechanisms/pow)のマイニングアルゴリズムと関連するコンセンサスロジックをオフにして、代わりに[プルーフ・オブ・ステーク](/developers/docs/consensus-mechanisms/pos)をオンにするというものでした。 パリ自体は、[実行クライアント](/developers/docs/nodes-and-clients/#execution-clients)へのアップグレード(コンセンサスレイヤーのベラトリックスに相当)であり、接続されている[コンセンサスクライアント](/developers/docs/nodes-and-clients/#consensus-clients)からの指示を可能にしましたが、 これにより、[エンジン API](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md)と称される新しい一連の内部 API メソッドを有効にする必要がありました。 このアップグレードは間違いなく、 [ホームステッド](#homestead)以来、イーサリアム史上最も重要なものとなりました。 +上海アップグレードにより、実行レイヤーへのステーキングの引き出しが可能になりました。 カペラのアップグレードと並行して、引き出し操作を受け付けられるようになり、ステーカーはビーコンチェーンから実行レイヤーにETHを引き出せるようになりました。 -- [パリのアップグレード仕様を読む](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/paris.md) + - + + EIP-3651 – COINBASEアドレスをウォームで開始 + EIP-3855 – 新規PUSH0命令 + EIP-3860 – リミットとメーターの初期コード + EIP-4895 – 操作としてのビーコンチェーンプッシュ引き出し + EIP-6049 - SELFDESTRUCTの廃止 + + -- [EIP-3675](https://eips.ethereum.org/EIPS/eip-3675) – コンセンサスをプルーフ・オブ・ステークにアップグレード -- [EIP-4399](https://eips.ethereum.org/EIPS/eip-4399) – PREVRANDAO で DIFFICULTY オペコードを置き換える +- [Shanghaiアップグレードの仕様を読む](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/shanghai.md) +#### Capellaの概要 {#capella-summary} + +カペラのアップグレードは、コンセンサスレイヤー(ビーコンチェーン)に対する3番目の主要なアップグレードであり、ステーキングの引き出しが可能になりました。 カペラは、実行レイヤーのアップグレードである上海と同期して起こり、ステーキングの引き出し機能が有効になりました。 + +このコンセンサスレイヤのアップグレードにより、最初の入金で引き出し認証情報を提供しなかったステーカーによる引き出しが可能になりました。 + +また、このアップグレードによって、自動アカウントスイープ機能も実装され、バリデータアカウントを継続的に処理し、報酬の支払いや全額引き出しができるようになりました。 + +- [ステーキング出金について詳しく](/staking/withdrawals/). +- [Capellaアップグレードの仕様を読む](https://github.com/ethereum/consensus-specs/blob/dev/specs/capella/) + + + +## 2022 {#2022} + +### Paris (The Merge) {#paris} + + + +#### まとめ {#paris-summary} + +Parisアップグレードは、プルーフ・オブ・ワーク・ブロックチェーンが[最終合計難易度(Terminal Total Difficulty)](/glossary/#terminal-total-difficulty) 58750000000000000000000を通過したことでトリガーされました。 2022年9月15日にブロック15537393で発生し、次のブロックでパリのアップグレードがトリガーされたものです。 Parisは[The Merge](/roadmap/merge/)への移行でした。その主な特徴は、[プルーフ・オブ・ワーク](/developers/docs/consensus-mechanisms/pow)のマイニングアルゴリズムと関連するコンセンサスロジックをオフにし、代わりに[プルーフ・オブ・ステーク](/developers/docs/consensus-mechanisms/pos)をオンにすることでした。 Paris自体は[実行クライアント](/developers/docs/nodes-and-clients/#execution-clients)へのアップグレードであり(コンセンサスレイヤーにおけるBellatrixに相当)、接続された[コンセンサスクライアント](/developers/docs/nodes-and-clients/#consensus-clients)からの指示を受け取ることができるようになりました。 これには、総称して[Engine API](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md)として知られる新しい一連の内部APIメソッドを有効化する必要がありました。 これは、[Homestead](#homestead)以降のイーサリアムの歴史において、間違いなく最も重要なアップグレードでした。 + +- [Parisアップグレードの仕様を読む](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/paris.md) + + + + + EIP-3675 – コンセンサスをアップグレードし、プルーフ・オブ・ステークにする。 + EIP-4399 – オペコードDIFFICULTYをPREVRANDAOに置き換える。 + --- -### ベラトリックス {#bellatrix} +### Bellatrix {#bellatrix} -Sep-06-2022 11:34:47 AM +UTC エポック番号: 144,896 ETH 価格: $1,558 USD waybackmachine 上の ethereum.org + -#### 要約 {#bellatrix-summary} +#### まとめ {#bellatrix-summary} -ベラトリックスのアップグレードは、[ビーコンチェーン](/upgrades/beacon-chain)で 2 番目にスケジュールされたアップグレードで、 [マージ](/upgrades/merge/)へ向けてチェーンを準備しました。 これにより、バリデータのペナルティを、非アクティブおよびスラッシング可能な違反に対して完全な値にしました。 ベラトリックスには、マージ向けチェーンと、最後のプルーフ・オブ・ワークのブロックから最初のプルーフ・オブ・ステークのブロックへの移行を準備するためのフォーク選択ルールのアップデートも含まれます。 このアップグレードで、コンセンサスクライアントに 58750000000000000000000000 の[最終合計難易度](/glossary/#terminal-total-difficulty)を認識させます。 +Bellatrixアップグレードは、[ビーコンチェーン](/roadmap/beacon-chain)で2番目に予定されていたアップグレードで、チェーンを[The Merge](/roadmap/merge/)に備えさせるものでした。 これにより、バリデータのペナルティを、非アクティブおよびスラッシング可能な違反に対して完全な値にしました。 ベラトリックスには、マージ向けチェーンと、最後のプルーフ・オブ・ワークのブロックから最初のプルーフ・オブ・ステークのブロックへの移行を準備するためのフォーク選択ルールのアップデートも含まれます。 これには、コンセンサスクライアントに58750000000000000000000の[最終合計難易度(Terminal Total Difficulty)](/glossary/#terminal-total-difficulty)を認識させることが含まれます。 -- [ベラトリックスのアップデート仕様を読む](https://github.com/ethereum/consensus-specs/tree/dev/specs/bellatrix) +- [Bellatrixアップグレードの仕様を読む](https://github.com/ethereum/consensus-specs/tree/dev/specs/bellatrix) --- -### グレイ・グレイシャー {#gray-glacier} - -Jun-30-2022 10:54:04 AM +UTC ブロック番号: 15,050,000 ETH 価格: $1,069 USD waybackmachine 上の ethereum.org +### Gray Glacier {#gray-glacier} -#### 要約 {#gray-glacier-summary} + -グレイ・グレイシャー・ネットワークのアップグレードによって、[ディフィカルティボム](/glossary/#difficulty-bomb)は 3 ヶ月延期となりました。 これが今回のアップグレードで導入された唯一の変更であり、[アロー・グレイシャー](#arrow-glacier)と[ミュア・グレーシャー](#muir-glacier)と似た性質のアップグレードとなります。 [ビザンチウム](#byzantium)、[コンスタンティノープル](#constantinople)、[ロンドン](#london)のネットワークアップグレードで同様の変更が実施されています。 +#### まとめ {#gray-glacier-summary} -- [EF ブログ - アロー・グレイシャーのアップグレードのお知らせ](https://blog.ethereum.org/2022/06/16/gray-glacier-announcement/) +Gray Glacierネットワークアップグレードは、[ディフィカルティボム](/glossary/#difficulty-bomb)を3ヶ月間延期しました。 これは、このアップグレードで導入された唯一の変更であり、[Arrow Glacier](#arrow-glacier)および[Muir Glacier](#muir-glacier)アップグレードと性質が似ています。 [Byzantium](#byzantium)、[Constantinople](#constantinople)、および[London](#london)のネットワークアップグレードでも同様の変更が実施されています。 - +- [EFブログ - Gray Glacierアップグレードのお知らせ](https://blog.ethereum.org/2022/06/16/gray-glacier-announcement/) -- [EIP-5133](https://eips.ethereum.org/EIPS/eip-5133) – 2022 年 9 月までディフィカルティボムを延期 + + + EIP-5133 – 2022年9月まで難易度爆弾を遅らせる。 + -## 2021 年 {#2021} +## 2021 {#2021} -### アロー・グレイシャー {#arrow-glacier} +### Arrow Glacier {#arrow-glacier} -Dec-09-2021 07:55:23 PM +UTC ブロック番号: 13,773,000 ETH 価格: $4111 USD waybackmachine 上の ethereum.org + -#### 要約 {#arrow-glacier-summary} +#### まとめ {#arrow-glacier-summary} -アロー・グレイシャーのネットワークのアップグレードにより、[ディフィカルティボム](/glossary/#difficulty-bomb)は数ヶ月延期されました。 これが今回のアップグレードで導入された唯一の変更であり、[ミュア・グレイシャー](#muir-glacier)と似た性質のアップグレードとなります。 同様の変更は、[ビザンチウム](#byzantium)、[コンスタンティノープル](#constantinople)および[ロンドン](#london)のネットワークアップグレードで行われています。 +Arrow Glacierネットワークアップグレードは、[ディフィカルティボム](/glossary/#difficulty-bomb)を数ヶ月延期しました。 これは、このアップグレードで導入された唯一の変更であり、[Muir Glacier](#muir-glacier)アップグレードと性質が似ています。 [Byzantium](#byzantium)、[Constantinople](#constantinople)、および[London](#london)のネットワークアップグレードでも同様の変更が実施されています。 -- [EF ブログ - アロー・グレイシャーのアップグレードのお知らせ](https://blog.ethereum.org/2021/11/10/arrow-glacier-announcement/) -- [Ethereum Cat Herders - イーサリアムのアロー・グレイシャーのアップグレード](https://medium.com/ethereum-cat-herders/ethereum-arrow-glacier-upgrade-e8d20fa4c002) +- [EFブログ - Arrow Glacierアップグレードのお知らせ](https://blog.ethereum.org/2021/11/10/arrow-glacier-announcement/) +- [Ethereum Cat Herders - Ethereum Arrow Glacierアップグレード](https://medium.com/ethereum-cat-herders/ethereum-arrow-glacier-upgrade-e8d20fa4c002) - - -- [EIP-4345](https://eips.ethereum.org/EIPS/eip-4345) – 2022 年 6 月までデフィカルティボムを順延 + + + EIP-4345 – 2022年6月まで難易度爆弾を遅らせる。 + --- -### アルタイル {#altair} +### Altair {#altair} -Oct-27-2021 10:56:23 AM +UTC エポック番号: 74,240 ETH 価格: $4024 USD waybackmachine 上の ethereum.org + -#### 要約 {#altair-summary} +#### まとめ {#altair-summary} -アルタイルのアップグレードは、 [ビーコンチェーン](/upgrades/beacon-chain)で最初に計画されたアップグレードです。 ライトクライアントをサポートするための「同期委員会」を追加しました。また、マージに向けた開発が進むにつれて、バリデータの非アクティブ化とスラッシングのペナルティが増加しました。 +Altairアップグレードは、[ビーコンチェーン](/roadmap/beacon-chain)で最初に予定されていたアップグレードです。 ライトクライアントをサポートするための「同期委員会」を追加しました。また、マージに向けた開発が進むにつれて、バリデータの非アクティブ化とスラッシングのペナルティが増加しました。 -- [アルタイルのアップデート仕様を読む](https://github.com/ethereum/consensus-specs/tree/dev/specs/altair) +- [Altairアップグレードの仕様を読む](https://github.com/ethereum/consensus-specs/tree/dev/specs/altair) -#### 豆知識 {#altair-fun-fact} +#### 豆知識! {#altair-fun-fact} -アルタイルは、正確な実装時間があらかじめ設定された最初の主要なネットワークアップグレードでした。 それまでのアップグレードはすべて、ブロックタイムにばらつきがあるプルーフ・オブ・ワーク・チェーン上のブロック番号に基づいていました。 ビーコンチェーンは、プルーフ・オブ・ワークを必要としない代わりに、バリデータがブロックを提案できる 32 秒の「スロット」からなる時間ベースのエポックシステムで動作します。 こうした理由から、エポック 74,240 に到達してアルタイルが実装されるタイミングを把握することができたのです。 +アルタイルは、正確な実装時間があらかじめ設定された最初の主要なネットワークアップグレードでした。 それまでのアップグレードはすべて、ブロックタイムにばらつきがあるプルーフ・オブ・ワーク・チェーン上のブロック番号に基づいていました。 ビーコンチェーンは、プルーフ・オブ・ワークを必要としない代わりに、バリデータがブロックを提案できる32秒の「スロット」からなる時間ベースのエポックシステムで動作します。 こうした理由から、エポック74,240に到達してアルタイルが実装されるタイミングを把握することができたのです。 -- [ブロックタイム](/developers/docs/blocks/#block-time) +- [ブロック時間](/developers/docs/blocks/#block-time) --- -### ロンドン {#london} +### London {#london} + + - Aug-05-2021 12:33:42 PM +UTC ブロック番号: 12,965,000 ETH 価格: $2621 USD waybackmachine 上の ethereum.org +#### まとめ {#london-summary} -#### 要約 {#london-summary} +Londonアップグレードでは[EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)が導入され、トランザクション手数料市場が改革されるとともに、ガス返金の処理方法や[Ice Age(氷河期)](/glossary/#ice-age)のスケジュールが変更されました。 -ロンドンのアップグレードでは、 [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)を導入し、トランザクションフィーの市場を改革するとともに、ガスの払い戻し方法や[氷河期](/glossary/#ice-age)のスケジュールを変更しました。 +#### ロンドンアップグレード/EIP-1559の更新内容 {#eip-1559} -- [dapp デベロッパーの方は、 ライブラリとツールをアップグレードしてください。](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/london-ecosystem-readiness.md) -- [イーサリアム・ファウンデーションのお知らせを読む](https://blog.ethereum.org/2021/07/15/london-mainnet-announcement/) -- [Ethereum Cat Herder の説明を読む](https://medium.com/ethereum-cat-herders/london-upgrade-overview-8eccb0041b41) +ロンドンアップグレード前は、イーサリアムのブロックサイズは固定されていました。 ネットワーク需要が高い時期には、ブロックはフル稼働していたため、 ユーザーはしばしば需要の減少を待つ必要があり、トランザクションの追加が遅れて、ユーザーエクスペリエンスが悪化していました。 ロンドンアップグレードで、イーサリアムに可変サイズのブロックが導入されました。 - +イーサリアムネットワーク上のトランザクション手数料の計算方法は、2021年8月の[Londonアップグレード](/ethereum-forks/#london)で変更されました。 Londonアップグレード以前は、手数料は`base`と`priority`フィーを分離せずに、次のように計算されていました: -- [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) – トランザクションフィー市場の改善。 -- [EIP-3198](https://eips.ethereum.org/EIPS/eip-3198) – ブロックから`BASEFEE`を返却。 -- [EIP-3529](https://eips.ethereum.org/EIPS/eip-3529) - EVM 運用のためのガス払い戻しを削減。 -- [EIP-3541](https://eips.ethereum.org/EIPS/eip-3541) - 0xEF`で始まるコントラクトのデプロイを防止。 -- [EIP-3554](https://eips.ethereum.org/EIPS/eip-3554) – 2021 年 12 月までアイス・グレイシャーを順延。 +例えば、AliceがBobに1 ETHを支払う必要があるとしましょう。 このトランザクションのガスリミットは21,000ユニット、ガス価格は200 Gweiです。 +手数料の合計は、`Gas units (limit) * Gas price per unit`、つまり`21,000 * 200 = 4,200,000 gwei`(0.0042 ETH)となります。 + +Londonアップグレードで[EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)が導入されたことで、トランザクション手数料の仕組みは従来よりも複雑になりましたが、ガス手数料が予測しやすくなり、結果的にトランザクション手数料市場がより効率的になりました。 ユーザーは、トランザクションの実行に支払ってもよい額に対応する`maxFeePerGas`を指定してトランザクションを送信できます。その際、ガスの市場価格(`baseFeePerGas`)を超える額を支払うことはなく、チップを差し引いた差額が返金されることを理解しています。 + +このビデオでは、EIP-1559とその利点について説明しています:[EIP-1559 Explained](https://www.youtube.com/watch?v=MGemhK9t44Q) + +- [dappデベロッパーの方へ。 ライブラリとツールを必ずアップグレードしてください。](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/london-ecosystem-readiness.md) +- [イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2021/07/15/london-mainnet-announcement/) +- [Ethereum Cat Herderによる解説を読む](https://medium.com/ethereum-cat-herders/london-upgrade-overview-8eccb0041b41) + + + + + EIP-1559 – トランザクション市場の改善。 + EIP-3198 – ブロックからBASEFEEを戻す。 + EIP-3529 - EVM操作のガス払い戻しを減額。 + EIP-3541 - 0xEFで始まるコントラクトのデプロイを防止。 + EIP-3554 – 氷河期を2021年12月まで遅らせる。 + --- -### ベルリン {#berlin} - - Apr-15-2021 10:07:03 AM +UTC ブロック番号: 12,244,000 ETH 価格: $2454 USD waybackmachine 上の ethereum.org +### Berlin {#berlin} -#### 要約 {#berlin-summary} + -ベルリンアップグレードにより、特定の EVM 活動に対するガスコストが最適化され、複数処理タイプへのサポートが向上しました。 +#### まとめ {#berlin-summary} -- [イーサリアム・ファウンデーションの発表を読む](https://blog.ethereum.org/2021/03/08/ethereum-berlin-upgrade-announcement/) -- [Ethereum Cat Herder の説明を読む](https://medium.com/ethereum-cat-herders/the-berlin-upgrade-overview-2f7ad710eb80) +ベルリンアップグレードにより、特定のEVM活動に対するガスコストが最適化され、複数処理タイプへのサポートが向上しました。 - +- [イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2021/03/08/ethereum-berlin-upgrade-announcement/) +- [Ethereum Cat Herderによる解説を読む](https://medium.com/ethereum-cat-herders/the-berlin-upgrade-overview-2f7ad710eb80) -- [EIP-2565](https://eips.ethereum.org/EIPS/eip-2565) – ModExp のガスコストを削減。 -- [EIP-2718](https://eips.ethereum.org/EIPS/eip-2718) – 複数のトランザクションタイプへの対応を簡素化。 -- [EIP-2929](https://eips.ethereum.org/EIPS/eip-2929) – ステートアクセスオペコードのガスコストを増加。 -- [EIP-2930](https://eips.ethereum.org/EIPS/eip-2930) – 任意アクセスリストを追加。 + + + EIP-2565 – ModExpのガス代の削減。 + EIP-2718 – 複数のトランザクションタイプのサポートを容易に。 + EIP-2929 – 状態にアクセスするオペコードのガス代の引き上げ。 + EIP-2930 – オプションのアクセスリストの追加。 + -## 2020 年 {#2020} +## 2020 {#2020} ### ビーコンチェーンの誕生 {#beacon-chain-genesis} - Dec-01-2020 12:00:35 PM +UTC ビーコンチェーンのブロック番号: 1 ETH 価格: $586.23 USD waybackmachine 上の ethereum.org + -#### 要約 {#beacon-chain-genesis-summary} +#### まとめ {#beacon-chain-genesis-summary} -[ビーコンチェーン](/upgrades/beacon-chain/)を安全にリリースするためには、32ETH をデポジットするステーキング参加者が 16384 に達することが必要条件でした。 11 月 27 日にこの数に到達したことで、2020 年 12 月 1 日にビーコンチェーンがブロックを生産することになりました。 これは、[イーサリアムのビジョン](/roadmap/vision/)を達成するための重要な第一歩です。 +[ビーコンチェーン](/roadmap/beacon-chain/)を安全にリリースするには、32 ETHのステーキングデポジットが16,384件必要でした。 これは11月27日に行われ、ビーコンチェーンは2020年12月1日にブロックの生成を開始しました。 -[イーサリアム・ファウンデーションの発表を読む](https://blog.ethereum.org/2020/11/27/eth2-quick-update-no-21/) +[イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2020/11/27/eth2-quick-update-no-21/) - + ビーコンチェーン --- -### ステーキングのデポジットコントラクトのデプロイ {#staking-deposit-contract} +### ステーキングデポジットコントラクトがデプロイされる {#staking-deposit-contract} - Oct-14-2020 09:22:52 AM +UTC ブロック番号: 11,052,984 ETH 価格: $379.04 USD waybackmachine 上の ethereum.org + -#### 要約 {#deposit-contract-summary} +#### まとめ {#deposit-contract-summary} -ステーキングのデポジットコントラクトによって、イーサリアムエコシステムに[ステーキング](/glossary/#staking)が導入されました。 [メインネット](/glossary/#mainnet)上のコントラクトですが、重要な[イーサリアムアップグレード](/upgrades/beacon-chain/)である[ビーコンチェーン](/upgrades/)の立ち上げスケジュールに大きな影響を与えました。 +ステーキングデポジットコントラクトにより、イーサリアムエコシステムに[ステーキング](/glossary/#staking)が導入されました。 [メインネット](/glossary/#mainnet)上のコントラクトですが、重要な[イーサリアムアップグレード](/roadmap/)である[ビーコンチェーン](/roadmap/beacon-chain/)の立ち上げスケジュールに大きな影響を与えました。 -[イーサリアム・ファウンデーションの発表を読む](https://blog.ethereum.org/2020/11/04/eth2-quick-update-no-19/) +[イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2020/11/04/eth2-quick-update-no-19/) ステーキング @@ -235,255 +401,263 @@ sidebarDepth: 1 --- -### ミュア・グレイシャー {#muir-glacier} +### Muir Glacier {#muir-glacier} - Jan-02-2020 08:30:49 AM +UTC ブロック番号: 9,200,000 ETH 価格: $127.18 USD waybackmachine 上の ethereum.org + -#### 要約 {#muir-glacier-summary} +#### まとめ {#muir-glacier-summary} -ミュア・グレイシャーのフォークでは、[ディフィカルティボム](/glossary/#difficulty-bomb)の順延が導入されました。 [プルーフ・オブ・ワーク](/developers/docs/consensus-mechanisms/pow/)合意メカニズムのブロック難易度の上昇は、トランザクションの送信や Dapps の使用にかかる待ち時間を増加させることで、イーサリアムの使い勝手を低下させる恐れがありました。 +Muir Glacierフォークでは、[ディフィカルティボム](/glossary/#difficulty-bomb)の延期が導入されました。 [プルーフ・オブ・ワーク](/developers/docs/consensus-mechanisms/pow/)コンセンサスメカニズムのブロック難易度の上昇は、トランザクションの送信やdappsの使用にかかる待機時間を増加させることで、イーサリアムのユーザビリティを低下させる恐れがありました。 -- [イーサリアム・ファウンデーションの発表を読む](https://blog.ethereum.org/2019/12/23/ethereum-muir-glacier-upgrade-announcement/) -- [Ethereum Cat Herder の説明を読む](https://medium.com/ethereum-cat-herders/ethereum-muir-glacier-upgrade-89b8cea5a210) +- [イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2019/12/23/ethereum-muir-glacier-upgrade-announcement/) +- [Ethereum Cat Herderによる解説を読む](https://medium.com/ethereum-cat-herders/ethereum-muir-glacier-upgrade-89b8cea5a210) - - -- [EIP-2384](https://eips.ethereum.org/EIPS/eip-2384) - ディフィカルティボムをさらに 4,000,000 ブロック(~ 611 日)延期。 + + + EIP-2384 – 難易度爆弾をさらに400万ブロック(約611日)遅らせる。 + -## 2019 年 {#2019} +## 2019 {#2019} -### イスタンブール (Istanbul) {#istanbul} +### Istanbul {#istanbul} - Dec-08-2019 12:25:09 AM +UTC ブロック番号: 9,069,000 ETH 価格: $151.06 USD waybackmachine 上の ethereum.org + -#### 要約 {#istanbul-summary} +#### まとめ {#istanbul-summary} イスタンブールのフォーク -- [EVM](/glossary/#gas)内の特定のアクションの[ガス](/developers/docs/ethereum-stack/#ethereum-virtual-machine)コストを最適化。 -- DOS 攻撃からの耐性を向上。 -- SNARKs と STARKs に基づいた[レイヤー 2 スケーリング](/developers/docs/scaling/#layer-2-scaling)ソリューションのパフォーマンスを向上。 -- イーサリアムと Zcash の相互運用を有効化。 +- [EVM](/developers/docs/ethereum-stack/#ethereum-virtual-machine)における特定のアクションの[ガス](/glossary/#gas)コストを最適化しました。 +- DOS攻撃からの耐性を向上。 +- SNARKとSTARKに基づく[レイヤー2スケーリング](/developers/docs/scaling/#layer-2-scaling)ソリューションのパフォーマンスを向上させました。 +- イーサリアムとZcashの相互運用を有効化。 - コントラクトに多数のクリエイティブな機能の導入を許可。 -[イーサリアム・ファウンデーションの発表を読む](https://blog.ethereum.org/2019/11/20/ethereum-istanbul-upgrade-announcement/) - - +[イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2019/11/20/ethereum-istanbul-upgrade-announcement/) -- [EIP-152](https://eips.ethereum.org/EIPS/eip-152) - イーサリアムが Zcash のようなプライバシーを保護する通貨と連携することを許可。 -- [EIP-1108](https://eips.ethereum.org/EIPS/eip-1108) - [gas](/glossary/#gas)のコストを改善するための安価な暗号化。 -- [EIP-1344](https://eips.ethereum.org/EIPS/eip-1344) - `CHAINID` [opcode](/developers/docs/ethereum-stack/#ethereum-virtual-machine)を追加することによってリプレイ攻撃からイーサリアムを保護。 -- [EIP-1884](https://eips.ethereum.org/EIPS/eip-1884) - 消費量に基づく opcode ガス価格の最適化。 -- [EIP-2028](https://eips.ethereum.org/EIPS/eip-2028) - ブロック内に、より多くのデータを格納するために CallData のコストを削減。 - [レイヤー 2 スケーリング](/developers/docs/scaling/#layer-2-scaling)に良い。 -- [EIP-2200](https://eips.ethereum.org/EIPS/eip-2200) - 他のオペコードのガス価格の変更。 + + + EIP-152 – イーサリアムをZcashのようなプライバシー保護通貨と連携可能に。 + EIP-1108 – 暗号処理をより安価にし、[ガス](/glossary/#gas)コストを改善する提案 + EIP-1344 – CHAINID [オペコード](/developers/docs/ethereum-stack/#ethereum-virtual-machine)を追加することで、リプレイ攻撃からEthereumを保護する提案 + EIP-1884 – 消費量に基づいてオペコードガス価格を最適化。 + EIP-2028 – CallDataのコストを削減し、ブロック内により多くのデータを格納できるようにする提案。これは[レイヤー2スケーリング](/developers/docs/scaling/#layer-2-scaling)に有効 + EIP-2200 – その他のオペコードのガス価格の変更。 + --- -### コンスタンティノープル {#constantinople} +### Constantinople {#constantinople} - Feb-28-2019 07:52:04 PM +UTC ブロック番号: 7,280,000 ETH 価格: $136.29 USD waybackmachine 上の ethereum.org + -#### 要約 {#constantinople-summary} +#### まとめ {#constantinople-summary} コンスタンティノープルのフォーク -- [プルーフ・オブ・ステーク](#beacon-chain-genesis)実装前にブロックチェーンがフリーズしなかったことを確認しました。 -- [EVM](/glossary/#gas)内の特定のアクションの[ガス](/developers/docs/ethereum-stack/#ethereum-virtual-machine)コストを最適化しました。 -- まだ作成されていないアドレスとやり取りする機能を追加しました。 +- ブロック[マイニング](/developers/docs/consensus-mechanisms/pow/mining/)報酬を3 ETHから2 ETHに削減しました。 +- [プルーフ・オブ・ステークが実装される](#beacon-chain-genesis)前に、ブロックチェーンがフリーズしないようにしました。 +- [EVM](/developers/docs/ethereum-stack/#ethereum-virtual-machine)における特定のアクションの[ガス](/glossary/#gas)コストを最適化しました。 +- まだ作成されていないアドレスとやり取りする機能を追加。 -[イーサリアム・ファウンデーションの発表を読む](https://blog.ethereum.org/2019/02/22/ethereum-constantinople-st-petersburg-upgrade-announcement/) +[イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2019/02/22/ethereum-constantinople-st-petersburg-upgrade-announcement/) - - -- [EIP-145](https://eips.ethereum.org/EIPS/eip-145) – 特定のオンチェーンアクションのコストを最適化。 -- [EIP-1014](https://eips.ethereum.org/EIPS/eip-1014) – まだ作成されていないアドレスとのやり取りを許可。 -- [EIP-1052](https://eips.ethereum.org/EIPS/eip-1052) – 特定のオンチェーンアクションのコストを最適化。 -- [EIP-1234](https://eips.ethereum.org/EIPS/eip-1234) – ブロックチェーンがプルーフ・オブ・ステーク実装前にフリーズしないよう確認。 + + + EIP-145 — 一部のオンチェーン処理のコストを最適化する。 + EIP-1014 – 作成前のアドレスとのやり取りを許可。 + EIP-1052 — 他のコントラクトのコードのハッシュ値を取得するための EXTCODEHASH 命令を導入する。 + EIP-1234 – ブロックチェーンがフリーズしないことを確認。また、ブロック報酬を3ETHから2ETHへ減額。 + -## 2017 年 {#2017} +## 2017 {#2017} -### ビザンチウム {#byzantium} +### Byzantium {#byzantium} - Oct-16-2017 05:22:11 AM +UTC ブロック番号: 4,370,000 ETH 価格: $334.23 USD waybackmachine 上の ethereum.org + -#### 要約 {#byzantium-summary} +#### まとめ {#byzantium-summary} ビザンチウムのフォーク -- ブロックの[マイニング](/developers/docs/consensus-mechanisms/pow/mining/)報酬が 5ETH から 3ETH へ減額されました。 -- [ディフィカルティボム](/glossary/#difficulty-bomb)を 1 年延期しました。 +- ブロック[マイニング](/developers/docs/consensus-mechanisms/pow/mining/)報酬を5 ETHから3 ETHに削減しました。 +- [ディフィカルティボム](/glossary/#difficulty-bomb)を1年間延期しました。 - 他のコントラクトに対して、状態変更を行わない呼び出しを行う機能を追加しました。 -- [レイヤー 2 スケーリング](/developers/docs/scaling/#layer-2-scaling)を可能にする特定の暗号技術を追加しました。 - -[イーサリアム・ファウンデーションの発表を読む](https://blog.ethereum.org/2017/10/12/byzantium-hf-announcement/) - - - -- [EIP-140](https://eips.ethereum.org/EIPS/eip-140) - `REVERT`オペコードを追加。 -- [EIP-658](https://eips.ethereum.org/EIPS/eip-658) - 成功か失敗かを示すために、トランザクションのレシートにステータスフィールドが追加。 -- [EIP-196](https://eips.ethereum.org/EIPS/eip-196) - [ZK-Snarks](/developers/docs/scaling/zk-rollups/)を可能にするために楕円曲線とスカラ乗算を追加。 -- [EIP-197](https://eips.ethereum.org/EIPS/eip-197) - [ZK-Snarks](/developers/docs/scaling/zk-rollups/)を可能にするために楕円曲線とスカラ乗算を追加。 -- [EIP-198](https://eips.ethereum.org/EIPS/eip-198) - RSA 署名の検証を有効化。 -- [EIP-211](https://eips.ethereum.org/EIPS/eip-211) - 可変長の戻り値のサポートを追加。 -- [EIP-214](https://eips.ethereum.org/EIPS/eip-214) - `STATICCALL`オペコードを追加し、他のコントラクトへの非状態変化コールを有効化。 -- [EIP-100](https://eips.ethereum.org/EIPS/eip-100) - 難易度調整式を変更。 -- [EIP-649](https://eips.ethereum.org/EIPS/eip-649) - [ディフィカルティボム](/glossary/#difficulty-bomb)を 1 年延期し、ブロック報酬を 5 から 3ETH に減額。 - +- [レイヤー2スケーリング](/developers/docs/scaling/#layer-2-scaling)を可能にする特定の暗号化メソッドを追加しました。 + +[イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2017/10/12/byzantium-hf-announcement/) + + + + + EIP-140 – オペコードREVERTの追加。 + EIP-658 – 成功また失敗を示すためにトランザクションレシートにステータスフィールドを追加。 + EIP-196 – 楕円曲線演算およびスカラー乗算を追加し、[ZK-Snarks](/developers/docs/scaling/zk-rollups/)を可能にする提案。 + EIP-197 – 楕円曲線演算およびスカラー乗算を追加し、[ZK-Snarks](/developers/docs/scaling/zk-rollups/)を可能にする提案。 + EIP-198 – RSA署名の検証を可能に。 + EIP-211 – 可変長戻り値のサポートを追加。 + EIP-214 – 他のコントラクトの非状態変更呼び出しを許可するオペコードSTATICCALLの追加。 + EIP-100 – 難易度調整の式を変更。 + EIP-649 – [ディフィカルティボム](/glossary/#difficulty-bomb)を1年間延期し、ブロック報酬を5ETHから3ETHに減少させる提案。 + -## 2016 年 {#2016} +## 2016 {#2016} -### スプリニアスドラゴン (Spurious Dragon) {#spurious-dragon} +### Spurious Dragon {#spurious-dragon} - Nov-22-2016 04:15:44 PM +UTC ブロック番号: 2,675,000 ETH 価格: $9.84 USD waybackmachine 上の ethereum.org + -#### 要約 {#spurious-dragon-summary} +#### まとめ {#spurious-dragon-summary} -スプリニアスドラゴンのフォークは、サービス拒否(DoS)攻撃に対する第 2 弾の対策でした。下記にその一部をご紹介します。 +スプリアスドラゴンのフォークは、ネットワークへのサービス拒否(DoS)攻撃(2016年9/10月)に対する第2弾の対策でした。下記にその一部をご紹介します。 - 将来のネットワーク攻撃を防ぐために、オペコードの価格を調整。 - ブロックチェーンステートの「デブロート」を有効化。 - リプレイ攻撃に対する保護を追加。 -[Ethereum 財団の発表を読む](https://blog.ethereum.org/2016/11/18/hard-fork-no-4-spurious-dragon/) - - +[イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2016/11/18/hard-fork-no-4-spurious-dragon/) -- [EIP-155](https://eips.ethereum.org/EIPS/eip-155) - あるイーサリアムチェーンからのトランザクションが、たとえばテストネットのトランザクションがメインのイーサリアムチェーンで再生されるなど、代替チェーン上で再ブロードキャストされることを防ぐ。 -- [EIP-160](https://eips.ethereum.org/EIPS/eip-160) - `EXP`オペコードの価格を調整 - 計算コストのかかるコントラクト操作によってネットワークをスローダウンすることで複雑化する。 -- [EIP-161](https://eips.ethereum.org/EIPS/eip-161) - DOS 攻撃で追加された空のアカウントを削除可能にする。 -- [EIP-170](https://eips.ethereum.org/EIPS/eip-170) - ブロックチェーン上のコントラクトの最大コードサイズを 24576 バイトに変更する。 + + + EIP-155 – あるイーサリアムチェーンのからトランザクションがもう一方のチェーンで再ブロードキャストされるのを防ぐ。例えば、テストネットのトランザクションが、イーサリアムのメインネットチェーンでリプレイされるなど。 + EIP-160 – オペコードであるEXPの価格調整 – 計算費用が高いコントラクト操作によってネットワークの速度を低下させることをより困難に。 + EIP-161 – DOS攻撃によって加えられた空アカウントの削除を可能に。 + EIP-170 – 最大コードサイズの変更。これにより、ブロックチェーンのコントラクトのサイズは、最大24576バイトに。 + --- -### タンジェリンホイッスル {#tangerine-whistle} +### Tangerine Whistle {#tangerine-whistle} - Oct-18-2016 01:19:31 PM +UTC ブロック番号: 2,463,000 ETH 価格: $12.50 USD waybackmachine 上の ethereum.org + -#### 要約 {#tangerine-whistle-summary} +#### まとめ {#tangerine-whistle-summary} -タンジェリンホイッスルのフォークは、サービス拒否(DoS)攻撃に対する第 1 弾の対策でした。下記にその一部をご紹介します。 +タンジェリンホイッスルのフォークは、ネットワークへのサービス拒否(DoS)攻撃(2016年9/10月)に対する第1弾の対策でした。下記にその一部をご紹介します。 - 安価な操作コードに関する緊急のネットワーク健全性問題への対処。 -[イーサリアム・ファウンデーションの発表を読む](https://blog.ethereum.org/2016/10/18/faq-upcoming-ethereum-hard-fork/) +[イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2016/10/18/faq-upcoming-ethereum-hard-fork/) - - -- [EIP-150](https://eips.ethereum.org/EIPS/eip-150) – スパム攻撃に使えるようにオペコードのガスコストの増加。 -- [EIP-158](https://eips.ethereum.org/EIPS/eip-158) – イーサリアムプロトコルの初期バージョンの欠陥により、非常に低いコストでステートに置かれた大量の空のアカウントを削除することにより、ステートのサイズを縮小。 + + + EIP-150 – スパム攻撃に使うことができるオペコードのガス代を引き上げ。 + EIP-158 – イーサリアムの以前のバージョンの欠陥により引き起こされた、非常に抵いコストでステートに置かれた大量の空アカウントを削除して、ステートサイズを縮小。 + --- -### DAO フォーク {#dao-fork} +### DAOフォーク {#dao-fork} - Jul-20-2016 01:20:40 PM +UTC ブロック番号: 1,920,000 ETH 価格: $12.54 USD waybackmachine 上の ethereum.org + -#### 要約 {#dao-fork-summary} +#### まとめ {#dao-fork-summary} -DAO フォークは、安全でない[自律分散型組織(DAO)](/glossary/#dao)のコントラクトが、1 回のハッキングによって、360 万以上の ETH を流出させた[2016 年の DAO 攻撃](https://www.coindesk.com/learn/understanding-the-dao-attack/)に対する対策でした。 フォークにより、欠陥のあるコントラクトから[新しいコントラクト](https://etherscan.io/address/0xbf4ed7b27f1d666546e30d74d50d173d20bca754)に資金が移されました。その際に使用した関数が withdraw です。 資金を失った人がウォレット内の 100DAO トークンごとに 1ETH を引き出せるようにしました。 +DAOフォークは、安全性の低い[DAO](/glossary/#dao)コントラクトから360万ETH以上がハッキングで流出した[2016年のDAO攻撃](https://www.coindesk.com/learn/understanding-the-dao-attack/)への対応でした。 このフォークにより、欠陥のあるコントラクトから資金が、引き出しという単一の機能を持つ[新しいコントラクト](https://eth.blockscout.com/address/0xbf4ed7b27f1d666546e30d74d50d173d20bca754)に移動されました。 資金を失った人がウォレット内の100DAOトークンごとに1ETHを引き出せるようにしました。 -この行動指針は Ethereum コミュニティの投票で行われました。 ETH 保有者は、 [投票プラットフォーム](http://v1.carbonvote.com/)でトランザクションを通じて投票することができました。 フォークの実行は、投票の 85%以上に支持されました。 +この行動指針はEthereumコミュニティの投票で行われました。 どのETH保有者も、[投票プラットフォーム](https://web.archive.org/web/20170620030820/http://v1.carbonvote.com/)上のトランザクションを介して投票することができました。 フォークの実行は、投票の85%以上に支持されました。 -DAO 事件はプロトコルの不具合によるものではなかったため、一部のマイナーはフォークを拒否しました。 その後 [イーサリアムクラシック](https://ethereumclassic.org/)を形成しました。 +DAO事件はプロトコルの不具合によるものではなかったため、一部のマイナーはフォークを拒否しました。 彼らは[Ethereum Classic](https://ethereumclassic.org/)を結成するに至りました。 -[イーサリアム・ファウンデーションの発表を読む](https://blog.ethereum.org/2016/07/20/hard-fork-completed/) +[イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2016/07/20/hard-fork-completed/) --- -### ホームステッド {#homestead} +### Homestead {#homestead} - Mar-14-2016 06:49:53 PM +UTC ブロック番号: 1,150,000 ETH 価格: $12.50 USD waybackmachine 上の ethereum.org + -#### 要約 {#homestead-summary} +#### まとめ {#homestead-summary} 未来を見据えたホームステッドのフォークで、 一部のプロトコル変更とネットワーク変更が含まれていたことで、イーサリアムはネットワークの追加アップグレードを行うことができました。 -[イーサリアム・ファウンデーションの発表を読む](https://blog.ethereum.org/2016/02/29/homestead-release/) - - +[イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2016/02/29/homestead-release/) -- [EIP-2](https://eips.ethereum.org/EIPS/eip-2) – コントラクト作成プロセスの編集。 -- [EIP-7](https://eips.ethereum.org/EIPS/eip-7) – `DELEGATECALL`オペコードの追加 。 -- [EIP-8](https://eips.ethereum.org/EIPS/eip-8) – devp2p フォワード互換性要求の導入。 + + + EIP-2 – コントラクトの作成プロセスを編集。 + EIP-7 – 新しいオペコードDELEGATECALLの追加。 + EIP-8 – devp2p前方向互換性要件の導入。 + -## 2015 年 {#2015} +## 2015 {#2015} -### フロンティアソーイング {#frontier-thawing} +### Frontier Thawing {#frontier-thawing} - Sep-07-2015 09:33:09 PM +UTC ブロック番号: 200,000 ETH 価格: $1.24 USD waybackmachine 上の ethereum.org + -#### 要約 {#frontier-thawing-summary} +#### まとめ {#frontier-thawing-summary} -フロンティアソーイングのフォークでは、1[ブロック](/glossary/#gas)あたり 5,000 の[ガス](/glossary/#block)リミットが解除され、デフォルトのガス価格が 51[gwei](/glossary/#gwei)に設定されました。 その結果、21,000 のガスが必要となるトランザクションが可能になりました。 [ディフィカルティボム](/glossary/#difficulty-bomb)は、[プルーフ・オブ・ステーク](/glossary/#pos)にハードフォークするために導入されました。 +Frontier Thawingフォークにより、[ブロック](/glossary/#block)あたりの5,000[ガス](/glossary/#gas)リミットが解除され、デフォルトのガス価格が51[Gwei](/glossary/#gwei)に設定されました。 その結果、21,000のガスが必要となるトランザクションが可能になりました。 [ディフィカルティボム](/glossary/#difficulty-bomb)は、将来の[プルーフ・オブ・ステーク](/glossary/#pos)へのハードフォークを確実にするために導入されました。 -- [イーサリアム・ファウンデーションの発表を読む](https://blog.ethereum.org/2015/08/04/the-thawing-frontier/) -- [イーサリアムプロトコルのアップデート 1 を読む](https://blog.ethereum.org/2015/08/04/ethereum-protocol-update-1/) +- [イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2015/08/04/the-thawing-frontier/) +- [イーサリアムプロトコルアップデート1を読む](https://blog.ethereum.org/2015/08/04/ethereum-protocol-update-1/) --- -### フロンティア {#frontier} +### Frontier {#frontier} - Jul-30-2015 03:26:13 PM +UTC ブロック番号: 0 ETH 価格: N/A waybackmachine 上の ethereum.org + -#### 要約 {#frontier-summary} +#### まとめ {#frontier-summary} -フロンティアは稼動していましたが、イーサリアムプロジェクトのベアボーン実装でした。 フオリンピックのテストフェーズの成功を受けて実装されたものであり、 技術系ユーザー、特にデベロッパー向けに開発されたものでした。 [ブロック](/glossary/#block)の[ガス](/glossary/#gas)リミットは、5,000 でした。 この「解凍」期間があったおかげで、マイナーはオペレーションを開始し、アーリーアダプターは「急ぐ」必要もなくクライアントをインストールすることができました。 +フロンティアは稼動していましたが、イーサリアムプロジェクトのベアボーン実装でした。 フオリンピックのテストフェーズの成功を受けて実装されたものであり、 技術系ユーザー、特にデベロッパー向けに開発されたものでした。 [ブロック](/glossary/#block)には、5,000の[ガス](/glossary/#gas)リミットがありました。 この「解凍」期間があったおかげで、マイナーはオペレーションを開始し、アーリーアダプターは「急ぐ」必要もなくクライアントをインストールすることができました。 -[イーサリアム・ファウンデーションの発表を読む](https://blog.ethereum.org/2015/07/22/frontier-is-coming-what-to-expect-and-how-to-prepare/) +[イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2015/07/22/frontier-is-coming-what-to-expect-and-how-to-prepare/) -## 2014 年 {#2014} +## 2014 {#2014} -### イーサの販売 {#ether-sale} +### Etherセール {#ether-sale} - 2014 年 7 月 22 日~ 9 月 2 日 waybackmachine 上の ethereum.org + -イーサは正式に 42 日間販売され、 BTC での購入も可能でした。 +イーサは正式に42日間販売され、 BTCでの購入も可能でした。 -[イーサリアム・ファウンデーションの発表を読む](https://blog.ethereum.org/2014/07/22/launching-the-ether-sale/) +[イーサリアム・ファウンデーションからのお知らせを読む](https://blog.ethereum.org/2014/07/22/launching-the-ether-sale/) --- -### イエローペーパーのリリース {#yellowpaper} +### イエローペーパーの公開 {#yellowpaper} - 2014 年 4 月 1 日 waybackmachine 上の ethereum.org + ギャビン・ウッド博士によって作成されたイエローペーパーには、イーサリアムプロトコルの技術的定義が記されています。 -[イエローペーパーを見る](https://github.com/ethereum/yellowpaper) +[イエローペーパーを表示する](https://github.com/ethereum/yellowpaper) -## 2013 年 {#2013} +## 2013 {#2013} -### ホワイトペーパーのリリース {#whitepaper} +### ホワイトペーパーの公開 {#whitepaper} - 2013 年 11 月 27 日 waybackmachine 上の ethereum.org + -この概要論文は、元々はイーサリアム創始者のヴィタリック・ブテリンにより 2013 年に発表されました。2015 年にプロジェクトが始動する前のことです。 +この概要論文は、元々はイーサリアム創始者のヴィタリック・ブテリンにより2013年に発表されました。2015年にプロジェクトが始動する前のことです。 - ホワイト ペーパー + ホワイトペーパー diff --git a/public/content/translations/ja/foundation/index.md b/public/content/translations/ja/foundation/index.md index 21b3d93500f..d173b1e5a7d 100644 --- a/public/content/translations/ja/foundation/index.md +++ b/public/content/translations/ja/foundation/index.md @@ -1,6 +1,6 @@ --- -title: イーサリアム・ファウンデーション -description: イーサリアムと関連技術をサポートする非営利団体であるイーサリアム・ファウンデーション(EF)について学びましょう。 +title: "イーサリアム・ファウンデーション" +description: "イーサリアムと関連技術をサポートする非営利団体であるイーサリアム・ファウンデーション(EF)について学びましょう。" hideEditButton: true lang: ja --- @@ -9,32 +9,32 @@ lang: ja -[イーサリアム・ファウンデーション](http://ethereum.foundation/)(EF)は、 [イーサリアム](/what-is-ethereum/)および関連技術をサポートする非営利団体です。 +[イーサリアム・ファウンデーション](http://ethereum.foundation/) (EF) は、[イーサリアム](/what-is-ethereum/)および関連技術をサポートする非営利団体です。 EFは企業でも、伝統的な非営利団体でもありません。 彼らの役割はイーサリアムを制御またはリードすることではなく、イーサリアム関連技術の重要な開発に資金を提供する唯一の組織でもありません。 EFは、はるかに大きな[エコシステム](/community/)の一部です。 -## イーサリアム・ファウンデーションの取り組み {#ethereum-foundation-initiatives} +## イーサリアム・ファウンデーションのイニシアチブ {#ethereum-foundation-initiatives} -### エコシステムサポートプログラム {#ecosystem-support-program} +### エコシステム・サポート・プログラム {#ecosystem-support-program} -[エコシステムサポートプログラム](https://esp.ethereum.foundation/)は、より大きなイーサリアムコミュニティ内のプロジェクトとエンティティに財政的および非財務的なサポートを提供するために存在します。その目的はエコシステムの成長を加速させることにあります。 エコシステムサポートプログラムは、主に財政支援に焦点を当てた元のイーサリアム助成プログラムの拡大です。 +[エコシステム・サポート・プログラム](https://esp.ethereum.foundation/)は、エコシステムの成長を加速させるために、広範なイーサリアムコミュニティ内のプロジェクトや団体に、資金的および非資金的な支援を提供するために存在します。 エコシステムサポートプログラムは、主に財政支援に焦点を当てた元のイーサリアム助成プログラムの拡大です。 -[esp.ethereum.found](https://esp.ethereum.foundation/)で、エコシステムサポートプログラム、過去の助成金の受領者、助成申請プロセスについて詳しく説明します。 もしくは、[エコシステムサポートプログラムブログ](https://blog.ethereum.org/category/ecosystem-support-program/)をご覧いただくか、[@EF_ESP](https://twitter.com/EF_ESP)をフォローして最新のニュースやお知らせをご覧ください。 +エコシステム・サポート・プログラム、過去の助成金受領者、および助成金申請プロセスに関する詳細は、[esp.ethereum.foundation](https://esp.ethereum.foundation/)をご覧ください。 また、[エコシステム・サポート・プログラムのブログ](https://blog.ethereum.org/category/ecosystem-support-program/)をご覧になったり、[@EF_ESP](https://twitter.com/EF_ESP)をフォローして、最新のニュースやお知らせを確認することもできます。 ### Devcon {#devcon} 2014年より、イーサリアム・ファウンデーションは、すべてのイーサリアムデベロッパー、研究者、思想家、メーカーのための年次会議である開発者会議(Devcon)を開催しています。 -[archive.devcon.org](https://archive.devcon.org/)にて、毎年の会議プレゼンテーションのビデオコンテンツにアクセスできます。 +初回から毎年開催されているカンファレンスのプレゼンテーションのビデオコンテンツには、[archive.devcon.org](https://archive.devcon.org/)からアクセスできます。 -詳細については、[devcon.org](https://devcon.org/)および[Devconブログ](https://devcon.org/en/blogs/)をご覧ください。また、[@efdevcon](https://twitter.com/EFDevcon)をフォローして最新のお知らせをご覧ください。 +詳細については[devcon.org](https://devcon.org/)をご覧になるか、[Devconブログ](https://devcon.org/en/blogs/)をご確認ください。また、[@efdevcon](https://twitter.com/EFDevcon)をフォローして最新のお知らせを受け取ることもできます。 -### フェローシッププログラム {#fellowship-program} +### フェローシップ・プログラム {#fellowship-program} -[イーサリアム・ファウンデーション・フェローシッププログラム](https://fellowship.ethereum.foundation/)は、国籍や文化、経済階級で生じる格差に対する支援イニシアチブです。 フェローシッププログラムは、ユニークで才能のある個人を特定、サポートすることでイーサリアムとの関連性を確立し、Web3の将来を担うコミュニティや評価されていない人々に対して門戸を開くことによって、こうしたギャップを埋めていくことを目的としています。 +[イーサリアム・ファウンデーション・フェローシップ・プログラム](https://fellowship.ethereum.foundation/)は、文化、国籍、経済階級を超えた代表性の格差に対処するためのイニシアチブです。 フェローシッププログラムは、ユニークで才能のある個人を特定、サポートすることでイーサリアムとの関連性を確立し、Web3の将来を担うコミュニティや評価されていない人々に対して門戸を開くことによって、こうしたギャップを埋めていくことを目的としています。 -[フェローシップ イーサリアム・ファウンデーション](https://fellowship.ethereum.foundation/)でもっと学ぶ。 +[詳細はfellowship.ethereum.foundationでご覧ください](https://fellowship.ethereum.foundation/) -ファウンデーションおよびファウンデーションの仕事の詳細については、[ethereum.foundation](http://ethereum.foundation/)、EFの最新のニュースとお知らせについては、[イーサリアム・ファウンデーションブログ](https://blog.ethereum.org/)をご覧ください。 +イーサリアム・ファウンデーションとその活動に関する詳細については、[ethereum.foundation](http://ethereum.foundation/)にアクセスするか、EFの最新ニュースやお知らせが掲載されている[イーサリアム・ファウンデーション・ブログ](https://blog.ethereum.org/)をご確認ください。 diff --git a/public/content/translations/ja/gaming/index.md b/public/content/translations/ja/gaming/index.md new file mode 100644 index 00000000000..3a317e54b69 --- /dev/null +++ b/public/content/translations/ja/gaming/index.md @@ -0,0 +1,70 @@ +--- +title: "オンチェーンゲーミング" +lang: ja +template: use-cases +image: /images/robot-help-bar.png +sidebarDepth: 2 +summaryPoint1: "ゲームのルールや状態は、スタジオのサーバーではなく、ブロックチェーンによって実行できます" +summaryPoint2: "誰でも、同じオンチェーンデータに接続するMODやボット、あるいは全く新しいゲームを構築できます" +summaryPoint3: "Redstoneのような専用L2やMUDのようなフレームワークは、リアルタイムのゲームプレイをサポートするのに十分なコスト削減を実現します" +buttons: + - content: 詳細 + toId: how-gaming-on-ethereum-works + - content: アプリを検索 + toId: popular-games-built-on-ethereum + isSecondary: false +--- + +## イーサリアムでのゲーミングの仕組み {#how-gaming-on-ethereum-works} + +イーサリアムでのゲーミングには、特定の機能のためにブロックチェーンを統合するゲームから、ゲームの世界全体がオンチェーンに存在するゲームまで、様々な形態があります。 多くのゲームが、ゲーム内アセットをNFT (非代替性トークン) として管理するためにイーサリアムを活用しています。 これによりプレイヤーは、ユニークなデジタルアイテムを真に所有し、単一のゲーム開発者のエコシステムの枠を超えて、オープンに取引、売却、贈与できます。 これらのアセットはプレイヤーに新たな形の主体性をオファーしますが、コアとなるゲームロジックは多くの場合、中央集権型のサーバー上に残ります。 + +完全にオンチェーンのゲームとは、基本的なメカニクス、そして多くの場合ゲームの世界全体が、イーサリアムのブロックチェーン (またはそのレイヤー2) 上のスマートコントラクトによって直接管理されるゲームのことです。 これにより、比類のない透明性が確保されます。 中央サーバーも、仲介者もありません。あるのは、透明でプレイヤー主導の体験と経済だけです。 + +- プレイヤーは自身のアセットをNFTとして所有します。 +- アイテムは自由に取引、贈与、売却できます。 +- ブロックチェーンは、アセットが永久にアクセス可能であることを保証します。 + +## ゲームの現状 {#the-current-state-of-gaming} + +- **頻繁なゲームのサービス終了:** 2023年だけで[60以上のゲームがサービスを終了](https://tech4gamers.com/game-studios-shut-down-2023/)し、11のゲームスタジオが完全に閉鎖され、プレイヤーのゲーム内投資は無駄になりました。 ロジックとアセットが分散型ネットワーク上にあるオンチェーンゲームは、ブロックチェーンが存在する限り存続でき、より高い永続性をオファーします。 +- **ロックされたアセットへの不満:** [ゲーマーの51%が、購入したゲーム内アイテムを贈与または再販できないことに不満を感じており](https://www.starknet.io/blog/blockchain-gaming/)、23%がゲーム内課金からお金を回収するのが難しいことに悩まされています。 プレイヤーは多大な時間とお金を投資してゲーム内アイテムを獲得しますが、結局はそれらを真に所有しているわけではないことに気づかされます。 イーサリアムのNFT標準は、検証可能なデジタル所有権を提供し、プレイヤーが自身のアセットを確実に管理できるようにします。 +- **リターンのない高額な支出:** [ゲーマーは生涯にわたって仮想アイテムに平均\$6,425](https://www.starknet.io/blog/blockchain-gaming/)を費やし、月平均\$8.74、年平均\$104を費やしています。 オンチェーンでの所有権は、その支出を埋没費用から、物理的なコレクティブル(収集品)のように売却、取引、贈与が可能なデジタルアセットへの投資へと変えます。 + +## イーサリアムで構築された人気ゲーム {#popular-games-built-on-ethereum} + +デベロッパーは、ゲームをより魅力的にし、単純な報酬メカニクスを超えて、スキルベースのゲームプレイを深化させる新しい方法を模索しています。 + + + +## プレイして稼ぐ (P2E) {#play-to-earn-p2e} + +プレイして稼ぐ (P2E) ゲームでは、現実世界で価値を持つゲーム内アセットを獲得できます。 持続不可能な報酬に依存していた初期のP2Eモデルとは異なり、新しいゲームは長期的な価値に焦点を当てています。 例えば、[Wolf Game](https://gam3s.gg/wolf-game/)は、戦略的なゲームプレイと真のデジタルアセット所有権を組み合わせています。 プレイヤーは仮想の羊と狼を管理し、取引や売却が可能なゲーム内通貨WOOLを獲得します。 + + + +## 相互運用性とクロスチェーンプレイ {#interoperability-and-cross-chain-play} + +ゲーミングにおけるイーサリアムの最も強力な機能の一つは、相互運用性と構成可能性をネイティブでサポートしている点です。 従来のゲームは「壁に囲まれた庭」の中で運営されており、ゲーム内アセットと進行状況は単一のタイトルに閉じ込められています。 イーサリアム上に構築されたゲーム内アセットや、さらにはコアとなるゲームロジックでさえ、セキュリティを犠牲にすることなく、異なるアプリケーションやチェーンを横断して相互作用する可能性があります。 これはまだ発展途上のエコシステムですが、一部のイーサリアムベースのゲームネットワークはすでに相互運用可能であり、ゲーム内アイテム (NFT) を複数のゲームで利用できるようになっています。 + +例えば、Illuviumでは、[プレイヤーはIlluvialと呼ばれるクリーチャーを集めることができ](https://gam3s.gg/news/illuvium-three-web3-games/)、これらはNFTです。 これらのIlluvialは、Illuviumの世界の中の様々なゲームで使うことができます。 Illuvium Overworldで捕獲したIlluvialは、Illuvium Arenaでのバトルでも使用できます。 + +もう一つの例はGalaxy Fight Clubです。 このゲームでは、[プレイヤーは異なるNFTコレクションを使用して](https://gam3s.gg/galaxy-fight-club/)バトルに参加できます。つまり、様々なプロジェクトのNFTをゲーム内で使用できるのです。 + +## スケーラビリティとガス代の改善 {#scalability-and-gas-fee-improvements} + +オンチェーンゲーミングに対するかつての批判として、ブロックチェーンは複雑で遅すぎるため、ゲーマーが期待する体験を提供できないというものがありました。 しかし、イーサリアムが成熟するにつれて、オンチェーンゲーミングのコストを大幅に削減し、パフォーマンスを向上させるソリューションが登場し、インタラクティブでペースの速い体験が実現可能になりました。 + +これらの進歩は、主に以下を通じて達成されます: + +- **ガスレス・トランザクション:** Immutable Xを活用しているものを含む一部のプラットフォームやプロトコルは、ユーザーが手数料なしでNFTの取引やミントなどのトランザクションを実行できる機能をオファーし、プレイヤー体験をさらに効率化しています。 +- **スケーリングソリューション:** Arbitrum、zkSync、StarknetなどのイーサリアムL2は、高いスループットと低コストのため、オンチェーンゲームのエコシステムを積極的に育成しています。 +- **[MUDエコシステム](https://mud.dev/):** MUDは、オンチェーンゲーム開発のためにイーサリアムベースのアプリケーション開発ツールキットを最適化し、複雑なゲームロジックに対してより効率的な状態管理を提供します。 + +## イーサリアムゲーミングを始めよう {#get-started-with-ethereum-gaming} + +イーサリアムゲーミングを始めるのは、あなたが思っているよりも簡単です。 わずか数ステップで、プレイを開始し、進行状況を楽しむことができます: + +1. **暗号通貨ウォレットを設定する:** デジタルアセットを管理し、分散型アプリケーションと対話するには、ウォレットが必要です。 [ウォレットを選択](/wallets/find-wallet/) +2. **ウォレットに資金を入金する:** イーサ (ETH) や、使用予定のレイヤー2ネットワークに関連するトークンを入手します。 +3. **ゲームを探す:** [Orden](https://orden.gg/)、 [ChainPlay](https://chainplay.gg/chain/ethereum/)、[Gam3s.GG](https://gam3s.gg/)、[DappRadar](https://dappradar.com/rankings/protocol/ethereum/category/games)、[OpenSea](https://opensea.io/)、[PlayToEarn.net](https://playtoearn.com/blockchaingames)などのプラットフォームでゲームを見つけましょう。 diff --git a/public/content/translations/ja/glossary/index.md b/public/content/translations/ja/glossary/index.md index d955023fbce..35f10bbb2b5 100644 --- a/public/content/translations/ja/glossary/index.md +++ b/public/content/translations/ja/glossary/index.md @@ -1,1131 +1,505 @@ --- -title: イーサリアム用語集 -description: イーサリアムに関連する専門用語および非専門用語の未完成の用語集。 +title: "イーサリアム用語集" +description: "イーサリアムに関連する専門用語および非専門用語の未完成の用語集。" lang: ja -sidebarDepth: 2 --- # 用語集 {#ethereum-glossary} - - ## \# {#section-numbers} -### 51%攻撃 {#51-attack} + -分散型[ネットワーク](#network)に対する攻撃の一種で、ある 1 つのグループが過半数の[ノード](#node)を支配すること。 その結果、[トランザクション](#transaction)を巻き戻したり、[イーサ](#ether)やその他のトークン消費を 2 倍にしたりすることでブロックチェーンの不正が可能となる。 + ## A {#section-a} -### アカウント(account) {#account} - -[アドレス](#address)、残高、 [ノンス](#nonce)、任意のストレージとコードを含むオブジェクト。 アカウントには、[コントラクトアカウント](#contract-account)と[外部所有口座(EOA)](#eoa)の 2 種類がある。 - - - イーサリアムアカウント - - -### アドレス (address) {#address} - -通常、アドレスはブロックチェーン上で[EOA](#eoa)またはコントラクトを表すものであり、 ブロックチェーン上で[トランザクション](#transaction)を受信(宛先アドレスの場合)または送信(送信元アドレスの場合)できる。 より具体的に言うと、[ECDSA](#keccak-256)[公開鍵](#ecdsa)の[Keccak ハッシュ](#public-key)の最も右側にある 160 ビットがアドレスである。 - -### アプリケーション・バイナリ・インターフェイス(ABI) {#abi} + -イーサリアムのエコシステムにおいて、 ブロックチェーンの外から、そしてコントラクト間の相互作用で[アカウント](#contract-account)とやり取りを行う標準的な方法。 + - - ABI - + -### アプリケーション・プログラミング・インターフェイス(API) {#api} + -アプリケーション・プログラミング・インターフェイス(API) は、ソフトウェアの使用方法に関する一連の定義。 API は、アプリケーションと Web サーバの間でデータの転送を行う。 + -### ASIC {#asic} + -特定用途向け集積回路。 通常、暗号通貨マイニング等用のカスタムメイドの集積回路のことを指す。 + -### アサート(assert) {#assert} + -[Solidity](#solidity)では、`assert(false)`は無効なオペコード`0xfe`にコンパイルされ、残りの[ガス](#gas)を使い切って全ての変更が巻き戻される。 `assert()`ステートメントでエラーが発生したときは、大きな間違いがあって、予期せぬことが起こっているため、コードを修正する必要がある。 `assert()`を使って、絶対に発生してはいけない条件を避けることが必要。 - - - スマートコントラクトのセキュリティ - - -### アテステーション(attestation) {#attestation} - -あることが真実であるというエンティティによる主張。 イーサリアムのコンテキストでは、コンセンサスバリデータは、チェーンのあるべき状態について主張しなければならない。 指定された時間に、各バリデータは、このバリデータのチェーンの状態の見解を正式に宣言するさまざまなアテステーションを発行する責任がある。アテステーションには、最後に確定されたチェックポイントとチェーンの現在のヘッドが含まれている。 - - - 認証根拠 - + ## B {#section-b} -### ベースフィー(Base Fee) {#base-fee} - -すべての[ブロック](#block)には「ベースフィー」と呼ばれるリザーブ価格がある。 ユーザーが次のブロックにトランザクションを含めるために支払わなければならない最低限の[ガス](#gas)代のこと。 - - - ガスと手数料 - - -### ビーコンチェーン(Beacon Chain) {#beacon-chain} - -ビーコンチェーンは、イーサリアムに[プルーフ・オブ・ステーク(PoS)](#pos)と[バリデータ](#validator)を導入したブロックチェーン。 2020 年 12 月から、2 つのチェーンが 2022 年 9 月にマージされ今日のイーサリアムを形成するまで、プルーフ・オブ・ワーク(PoW)のイーサリアムメインネットと並行して実行された。 - - - ビーコンチェーン - - -### ビッグエンディアン(big-endian) {#big-endian} - -最上位の桁がメモリ上で最初に位置する方式の数値表現のこと。 対義語のリトルエンディアン(little-endian)では最下位の桁がメモリ上の最初に位置する。 - -### ブロック(block) {#block} - -ブロックは、トランザクションの順序リストとコンセンサス関連情報を含む、バンドルされた情報の単位。 プルーフ・オブ・ステーク(PoS)のバリデータによって提案され、その時点ですべてのピアツーピアネットワーク全体で共有される。ここでは、他のすべてのノードによって容易に独立検証できる。 コンセンサスルールは、ブロックのどのコンテンツが有効かを決定し、無効なブロックはネットワークによって無視される。 これらのブロックとその中のトランザクションの順序付けにより、ネットワークの現在の状態を表す先端を持つ決定論的な一連のイベントが作成される。 - - - ブロック - - -### ブロックエクスプローラ(block explorer) {#block-explorer} - -ブロックチェーンに関する情報をユーザーが検索するためのインターフェイス。 これには、個々のトランザクションや特定のアドレスに関連する状況、およびネットワーク情報の取得が含まれる。 - -### ブロックヘッダ(block header) {#block-header} - -ブロックヘッダは、ブロックに関するメタデータと、実行ペイロードに含まれるトランザクションの概要をまとめたもの。 - -### ブロック伝播(block propagation) {#block-propagation} - -検証済みのブロックをネットワーク上の他のすべてのノードに送信するプロセス。 - -### ブロックプロポーザ(block proposer) {#block-proposer} - -特定の[スロット](#slot)にブロックを作成するために選ばれた特殊なバリデータ。 - -### ブロック報酬(block reward) {#block-reward} + -新たな有効ブロック提案者に報酬として支払われるイーサの量。 + -### ブロックステータス(block status) {#block-status} + -ブロックが存在できる状態。 可能な状態の一例を以下にご紹介します。 + -- 提案済み: ブロックがバリデータによって提案された -- スケジュール済み: バリデータが現在データを送信中 -- 失敗した/スキップした: 提案者が指定時間内にブロックを提案できなかった -- 孤立した: ブロックが[フォーク選択アルゴリズム](#fork-choice-algorithm)によって再編成された + -### ブロックタイム(block time) {#block-time} + -ブロックがブロックチェーンに追加される時間間隔。 + -### ブロックバリデーション(block validation) {#block-validation} + -新しいブロックに有効なトランザクションと署名が含まれていることを確認するプロセス。最も重く履歴のあるチェーン上に構築され、他のすべてのコンセンサスルールに従う。 有効なブロックはチェーンの末尾に追加され、ネットワーク上の他のブロックに伝播し、 無効なブロックは無視される。 + -### ブロックチェーン(blockchain) {#blockchain} + -[ブロック](#block)の連鎖。どのブロックも、前のブロックのハッシュを参照することによって[始まりのブロック](#genesis-block)まで繋がっている。 ブロックチェーンの整合性は、プルーフ・オブ・ステーク(PoS)に基づく合意メカニズムによって暗号資産エコシステム内で確保されている。 + - - ブロックチェーンとは - + -### ブートノード(bootnode) {#bootnode} + -あるノードを実行するとき、ディスカバリープロセスを開始するために使用できるノード。 これらのノードのエンドポイントは、イーサリアムのソースコードに記録される。 + -### バイトコード(bytecode) {#bytecode} + -ソフトウェアのインタープリタや仮想マシンで効率的に実行できるように設計された抽象的な命令セット。 ヒューマンリーダブルソースコードとは異なり、バイトコードは数値で表現される。 + -### ビザンチウムフォーク(Byzantium fork) {#byzantium-fork} - -2 段階に分かれた[メトロポリス(Metropolis)](#metropolis)開発の[ハードフォーク](#hard-fork)の最初の段階。 これには、EIP-649 のメトロポリス[難点爆弾](#difficulty-bomb)遅延とブロック報酬の減額が含まれており、[氷河期](#ice-age)は 1 年延期になり、ブロック報酬は 5 ether から 3 ether に減少した。 + ## C {#section-c} -### キャスパー FFG(Casper-FFG) {#casper-ffg} - -キャスパー FFG は、[LMD-GHOST](#lmd-ghost)フォーク・チョイス・アルゴリズムと組み合わせて実行されるプルーフ・オブ・ステーク(PoS)コンセンサスプロトコル。[コンセンサスクライアント](#consensus-client)によるビーコンチェーン先頭への合意を完了させる。 - -### チェックポイント(checkpoint) {#checkpoint} - -[ビーコンチェーン](#beacon-chain)には、スロット(12 秒)とエポック(32 スロット)に分かれたテンポがあり、 各エポックの最初のスロットはチェックポイントとなる。 バリデータの[スーパーマジョリティ](#supermajority)が 2 つのチェックポイント間のリンクを証明すると、それらは[正当](#justification)となり、その上に別のチェックポイントが正当化されると、[確定](#finality)となる。 - -### コンパイル(compiling) {#compiling} - -高レベルのプログラミング言語([Solidity](#solidity)など)で書かれたコードを低レベルの言語(EVM の[バイトコード](#bytecode)など)に変換すること。 - - - スマートコントラクトのコンパイル - - -### 委員会(committee) {#committee} - -最低 128 人の[バリデータ](#validator)からなる、各スロットのブロックを検証するために集められたグループ。 バリデータの中から 1 人が集計者となって、委員会内の他のバリデータの同意署名をまとめる責任を負う。 [同期委員会](#sync-committee)と混同しないこと。 - -### 計算不可能(computational infeasibility) {#computational-infeasibility} - -あるプロセスを実行しようと思った人たちにとって、非現実的にとても長い時間(たとえば数十億年)かかる場合、計算不可能となる。 - -### コンセンサス {#consensus} - -ネットワーク上のスーパーマジョリティのノードすべてが、ローカルで検証された最良のブロックチェーンに同一のブロックを持っている状態。 [コンセンサスルール](#consensus-rules)と混同しないこと。 - -### コンセンサスクライアント {#consensus-client} - -コンセンサスクライアント(Prysm、Teku、Nimbus、Lighthouse、Lodestar など)は、イーサリアムの[プルーフ・オブ・ステーク(PoS)](#pos)コンセンサスアルゴリズムを実行して、ビーコンチェーンの先頭でのネットワークの合意を得ることができる。 コンセンサスクライアントは、トランザクションの検証/ブロードキャスト、状態遷移の実行には参加しない。 [実行クライアント](#execution-client)によって行われる。 + -### コンセンサスレイヤー {#consensus-layer} + -イーサリアムのコンセンサスレイヤーは、[コンセンサスクライアント](#consensus-client)のネットワークです。 + -### コンセンサスルール(consensus rules) {#consensus-rules} + -他のノードとのコンセンサスを維持するために、フルノードが従うべきブロックの検証ルール。 [コンセンサス](#consensus)と混同しないこと。 + -### アップデートに含めるために検討(CFI: Considered for Inclusion) {#cfi} + -メインネットではまだアクティブになっていないコア[EIP](#eip)であり、通常クライアントデベロッパーは、このアイデアに対して肯定的。 メインネットに含めるためのすべての要件を満たしていると仮定すると、ネットワークのアップグレードに含まれる可能性がある(必ずしも次回のアップグレードとは限らない) 。 + -### コンスタンティノープルフォーク {#constantinople-fork} + -[メトロポリス](#metropolis)ステージの第 2 段階で、当初は 2018 年の半ばに計画されていた。 コンセンサスアルゴリズムを[プルーフ・オブ・ワーク(PoW)](#pow)と[プルーフ・オブ・ステーク(PoS)](#pos)のハイブリッドへと切り替えることも期待されていた。 + -### コントラクトアカウント {#contract-account} + -他の[アカウント](#account)([EOA](#eoa)または[コントラクト](#contract-account))から[トランザクション](#transaction)を受け取るたびに実行されるコードを含むアカウント。 + -### コントラクト作成トランザクション {#contract-creation-transaction} + -コントラクトの初期化コードを含む特別な[トランザクション](#transaction)。 受取人は、`null`に設定され、コントラクトはユーザーアドレスと`nonce`から生成されたアドレスにデプロイされる。 [コントラクト](#contract-account)を登録し、イーサリアムブロックチェーンに記録するために使用される。 + -### クリプトエコノミクス {#cryptoeconomics} + -暗号通貨の経済学。 + ## D {#section-d} -### Đ {#d-with-stroke} - -Đ(ストローク付の D)は、は、古英語、中英語、アイスランド語、フェロー語で、大文字の「Eth」の略として使われている。 ĐEV や Đapp(分散アプリケーション)などの単語で使用される。この「Đ」は北欧文字の「eth」。 大文字の eth(Ð)は、暗号通貨のドージコインのシンボルとしても使用される。 古いイーサリアムの文献でよく見られますが、今日ではあまり使用されていない。 - -### DAG {#dag} - -DAG は、Directed Acyclic Graph(有向非巡回グラフ)の略であり、 ノードとノード間のリンクで構成されるデータ構造。 マージ以前のイーサリアムでは、[プルーフ・オブ・ワーク(PoW)](#pow)アルゴリズムの[Ethash](#ethash)で DAG を使用していたが、現在の[プルーフ・オブ・ステーク(PoS)](#pos)では使用していない。 - -### 分散型アプリケーション(Dapp) {#dapp} - -分散型アプリケーション。 最小の構成は、[スマートコントラクト](#smart-contract)とウェブユーザーインターフェイス。 広義では、オープンな分散型の P2P インフラストラクチャサービス上に構築されている Web アプリケーション。 さらに、多くの Dapp には、分散型ストレージや、メッセージプロトコル、プラットフォームが含まれる。 - - - Dapp入門 - - -### データの可用性(data availability) {#data-availability} - -ネットワーク上のどのノードでも、任意の部分データをダウンロードできる状態。 - -### 分散化(decentralization) {#decentralization} - -プロセスの制御と実行を中央組織から移行するという概念です。 - -### 自律分散型組織(DAO) {#dao} - -階層的な管理をせずに運営されている会社やその他の組織のこと。 2016 年 4 月 30 日に立ち上げられた「The DAO」という名のコントラクトを指す場合もある。「The DAO」は 2016 年 6 月にハッキングされ、最終的にブロック 1,192,000 で[ハードフォーク](#hard-fork)(コードネーム: DAO)を実行させることとなり、ハッキングされた DAO コントラクトを巻き戻すことにした。これをきっかけに、イーサリアムとイーサリアムクラシックは競合する 2 つのシステムとして分裂。 - - - 分散型自律組織(DAO) - - -### 分散型取引所(DEX) {#dex} + -ネットワーク上のピアとトークンを取引できる[dapp](#dapp)の一種。 使用するには、([トランザクションフィー](#transaction-fee)を支払うため)[イーサリアム](#ether)が必要となるが、中央集権型取引所のような地理的制限はなく、誰でも使用可能。 + - - 分散型取引所 - + -### deed {#deed} + -[非代替性トークン(NFT)を参照](#nft)。 + -### デポジットコントラクト(deposit contract) {#deposit-contract} + -イーサリアムのステーキングの入り口。 デポジットコントラクトは、ETH のデポジットを受け入れ、バリデータの残高を管理するイーサリアム上のスマートコントラクト。 コントラクトに ETH を入金しないと、バリデータを有効にすることはできない。 コントラクトには、ETH と入力データが必要。 この入力データには、バリデータの公開鍵と、バリデータの秘密鍵によって署名された出金用の公開鍵が含まれる。 このデータは、バリデータが[プルーフ・オブ・ステーク(PoS)](#pos)ネットワークによって識別、承認されるために必要となる。 + -### 分散型金融(DeFi) {#defi} + -「非中央集権型金融」の略で、ブロックチェーン上の金融サービス[Dapps](#dapp)のより広義なカテゴリー。仲介業者を介さないため、インターネット環境があれば誰でも利用可能。 + - - 分散型金融(DeFi) - + -### 難易度(difficulty) {#difficulty} + -[プルーフ・オブ・ワーク(PoW)](#pow)ネットワークにおけるネットワーク全体の設定で、有効なノンスを見つけるために必要な平均計算量を制御。 難易度は、有効であると見なされるために得られたブロックハッシュに必要な先頭のゼロの数で表される。 このコンセプトは、プルーフ・オブ・ステークへの移行に伴いイーサリアムでは廃止。 + -### ディフィカルティボム(difficulty bomb) {#difficulty-bomb} + -計画的に[プルーフ・オブ・ワーク(PoW)](#pow)の[難易度](#difficulty)設定を急激に上げた。[プルーフ・オブ・ステーク(PoS)](#pos)への移行を促す目的で、[フォーク](#hard-fork)の機会を減らすために設計されたもの。 ディフィカルティボムは、[プルーフ・オブ・ステーク(PoS)](/upgrades/merge)への移行に伴い廃止。 + -### 電子署名(digital signature) {#digital-signatures} + -ユーザーが[秘密鍵](#private-key)を利用してドキュメントを生成する短い文字列で、対応する[公開鍵](#public-key)を利用して、誰でも(1)秘密鍵の所有者によってドキュメントに署名がなされたこと、(2) 署名後にドキュメントが変更されていないことを検証できる。 + -### ディスカバリー(Discovery) {#discovery} - -イーサリアムノードが接続する他のノードを見つけるプロセス。 - -### 分散ハッシュテーブル(DHT) {#distributed-hash-table} - -`(key, value)`ペアを含むデータ構造で、イーサリアムノードが接続するピアの特定と、通信に使用するプロトコルを決定するために使用される。 - -### 二重支払(double spend) {#double-spend} - -意図的なブロックチェーンフォークで、十分な量のマイニングパワーまたはステークを持つユーザーが、ある通貨をオフチェーンに移動するトランザクションを送信し (例: 不換紙幣に交換する、オフチェーンで購入するなど)、そのトランザクションを削除するためにブロックチェーンを再編成すること。 二重支払に成功すると、攻撃者はオンチェーンとオフチェーンの両方の資産を手に入れることができる。 - ## E {#section-e} -### 楕円曲線 DSA(ECDSA) {#ecdsa} - -所有者以外はその資金を使うことができないようにするイーサリアムの暗号論的アルゴリズム。 秘密鍵と公開鍵を作成するための好ましい方法。 アカウント[アドレス](#address)の生成や、[トランザクション](#transaction)の検証に関連している。 - -### 暗号化(encryption) {#encryption} - -暗号化とは、正しい復号化キーを持つ所有者以外は読めない形式に電子データを変換すること。 - -### エントロピー(entropy) {#entropy} - -暗号技術のコンテクストにおいては、予測可能性やランダム性の度合いを指す。 [秘密鍵](#private-key)のような機密情報を生成する際、アルゴリズムは通常、出力結果を予測不可能とするために高エントロピー源に依存する。 - -### エポック(epoch) {#epoch} - -32[スロット](#slot)の期間で、各スロットは 12 秒、合計 6.4 分。 バリデータ[委員会](#committee)はセキュリティ上の理由からエポックごとにシャッフルされる。 各エポックには、チェーンを[確定](#finality)する機会があり、 各バリデータには、各エポックの開始時に新しい役割が割り当てられる。 - - - プルーフ・オブ・ステーク - - -### 曖昧度(equivocation) {#equivocation} - -お互いに矛盾する 2 つのメッセージを送信するバリデータ。 シンプルな一例として挙げられるのは、トランザクション送信者が、同じノンスで 2 つのトランザクションを送信する場合。 もう一つの例としては、2 つのブロックを同じブロック高(または同じスロット)で提案するブロック提案者。 - -### Eth1 {#eth1} - -「Eth1」は、既存のプルーフ・オブ・ワーク(PoW)ブロックチェーンであるメインネットのイーサリアムを指す用語。 この用語は廃止予定となっており、「実行レイヤー」という用語を使用する。 この名前の変更についての詳細は、[こちら](https://blog.ethereum.org/2022/01/24/the-great-eth2-renaming/)を参照のこと。 - - - イーサリアムのアップグレードの詳細 - - -### Eth2 {#eth2} - -「Eth2」は、イーサリアムのプルーフ・オブ・ステーク(PoS)への移行を含む一連のイーサリアムプロトコルのアップグレードのこと。 この用語は廃止予定となっており、「コンセンサスレイヤー」という用語を使います。 [この名前の変更](https://blog.ethereum.org/2022/01/24/the-great-eth2-renaming/) についてもっと詳しく。 - - - イーサリアムのアップグレードの詳細 - - -### イーサリアム改善提案(EIP) {#eip} - -イーサリアムコミュニティに情報を提供するための設計文書。提案された新機能やプロセス、環境について説明している([ERC](#erc)を参照のこと)。 - - - EIP紹介 - - -### イーサリアム名サービス(ENS) {#ens} - -ENS レジストリは、単一の中央[コントラクト](#smart-contract)で、[EIP](#eip)137 に記述されているような、ドメイン名と所有者やリゾルバとの対応付けを提供。 - -[詳細は ens.domains を参照のこと。](https://ens.domains) - -### 実行クライアント {#execution-client} - -ベス (Besu) 、エリゴン (Erigon) 、Geth(Go-ethereum) 、ネザーマインド(Nethermind)などの実行クライアント(以前は「Eth1 クライアント」と呼ばれていた)のタスクは、トランザクションの処理とブロードキャスト、イーサリアムのステート(状態) の管理。 プロトコルのルールが守られていることを確認するために、[イーサリアム仮想マシン](#evm)を使用して各トランザクションの計算を実行する。 - -### 実行レイヤー {#execution-layer} + -イーサリアムの実行レイヤーは、[実行クライアント](#execution-client)のネットワーク。 + -### 外部所有アカウント(EOA) {#eoa} + -[秘密鍵](#private-key)によって制御される[アカウント](#account)のこと。通常は、[シードフレーズ](#hd-wallet-seed)を使用して生成される。 外部所有アカウントは、スマートコントラクトと違いコードが関連付けられていない。 通常、これらのアカウントは[ウォレット](#wallet)で管理される。 + -### コメントを求めるイーサリアムリクエスト(ERC) {#erc} + -一定の[EIP](#eip)に付与されるラベルで、イーサリアムの使用に関する特定の基準を定めたもの。 + - - EIP紹介 - + -### Ethash {#ethash} + -[プルーフ・オブ・ステーク(PoS)](#pos)に移行する前にイーサリアムで使用されていた[プルーフ・オブ・ワーク(PoW)](#pow)のアルゴリズム。 + -[続きを読む](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash) + -### イーサ(ether) {#ether} + -イーサリアムエコシステムによって使用されるネイティブ暗号通貨で、トランザクションの実行には[ガス](#gas)代がかかる。 ETH またはその記号をギリシャ文字の大文字で「Ξ」と表すこともできる。 + - - デジタル未来のための通貨 - + -### イベント (Event) {#events} + -[EVM](#evm)ロギング機能を利用できる。 [Dapp](#dapp)はイベントをリッスンし、ユーザーインタフェイス内の JavaScript で記述されたコールバックをトリガするために利用可能。 + - - イベントとログ(Events and Logs) - + -### イーサリアム仮想マシン(EVM) {#evm} + -[バイトコード](#bytecode)を実行するスタックベースの仮想マシン。 イーサリアムでは、一連のバイトコード命令と環境データの小さなタプルを与えられた場合に、システムの状態をどのように変化するかを実行モデルが指定する。 これは、仮想状態マシンの正則モデルによって指定されている。 + - - イーサリアム仮想マシン (EVM) - + -### EVM アセンブリ言語(EVM assembly language) {#evm-assembly-language} + -EVM の[バイトコード](#bytecode)をヒューマンリーダブル形式にしたもの。 + ## F {#section-f} -### フォールバック関数 (fallback function) {#fallback-function} + -データや宣言された関数名がない場合に呼び出されるデフォルトの関数のこと。 + -### フォーセット(faucet) {#faucet} + -[スマートコントラクト](#smart-contract)を介して実行されるサービスで、テストネットで使用できる無料のテスト用イーサの形で資金を分配する。 + - - テストネットのフォーセット - + -### ファイナリティ(finality) {#finality} + -ファイナリティとは、ある時点以前の一連のトランザクションが変更または撤回できないことを保証するもの。 + - - Proof-of-Stakeにおけるファイナリティ - - -### finney {#finney} - -[ether](#ether)の単位。 1 finney = 1015 [wei](#wei)。 103 finney = 1 ether。 - -### フォーク(fork) {#fork} - -プロトコルを変更することで、代替チェーンが生成されたり、一時的な分岐によって 2 つの潜在的なブロックパスが生成されたりする。 - -### フォーク選択アルゴリズム(fork-choice algorithm) {#fork-choice-algorithm} - -ブロックチェーンの先頭を特定するために使用されるアルゴリズム。 実行レイヤーでは、チェーンのヘッドは最大の難易度を持つものとして識別される。 つまり、チェーンの真のヘッドが、マイニングに最も多くの作業を要することを意味する。 コンセンサスレイヤーでは、アルゴリズムはバリデータ([LMD_GHOST](#lmd-ghost))から蓄積されたアテステーションを監視。 - -### 不正証明(fraud proof) {#fraud-proof} - -特定の[レイヤー 2](#layer-2)ソリューションに対するセキュリティモデルで、スピードを上げるために複数のトランザクションを 1 つのバッチに[ロールアップ](#rollups)して、1 つのトランザクションとしてイーサリアムに送信。 これらのトランザクションは有効とみなされるが、不正が疑われる場合にはチャレンジを受けることもある。 不正証明は、不正が疑われるときトランザクションを実行し、不正が行われたかどうかを検証する。 この方法は、セキュリティを保持しながら、可能なトランザクションの量を増やすことができる。 [ロールアップ](#rollups)の方法の中には、[有効性証明](#validity-proof)を利用しているものもある。 - - - 楽観的ロールアップ - - -### フロンティア(Frontier) {#frontier} - -2015 年 7 月から 2016 年 3 月までの間のイーサリアムの最初のテスト開発段階。 + ## G {#section-g} -### ガス {#gas} - -イーサリアムでスマートコントラクトを実行するための仮想燃料。 [EVM](#evm)は、ガスの消費量を測定し、コンピューティングリソースの消費を制限する会計メカニズムを使用している。([チューリング完了](#turing-complete)参照) - - - ガスと手数料 - - -### ガスリミット(gas limit) {#gas-limit} - -[トランザクション](#transaction)や[ブロック](#block)が消費する[ガス](#gas)の上限。 + -### ガス代(gas price) {#gas-price} + -所定トランザクション 1 回につきかかる価格(Ether)。 + -### 始まりのブロック(genesis block) {#genesis-block} + -[ブロックチェーン](#blockchain)の最初のブロックで、特定のネットワークとその暗号通貨を初期化するために使用される。 + -### geth {#geth} - -Go Ethereum。 Go で書かれたイーサリアムプロトコルの最も優れた実装の 1 つ。 - -[詳細は geth.ethereum.org を参照。](https://geth.ethereum.org/) - -### gwei {#gwei} - -Gigawei の略称で、通常[ガス](#gas)の価格に使われる[イーサ](#ether)の呼称。 1 gwei = 109 [wei](#wei)。 109 gwei = 1 ether。 + ## H {#section-h} -### ハードフォーク(hard fork) {#hard-fork} - -[ブロックチェーン](#blockchain)の恒久的な分岐。変更ハードフォークとしても知られる。 アップグレードされていないノードが、新しい[コンセンサスルール](#consensus-rules)に遵守するアップグレードされたノードによって作成されたブロックを検証できない場合、このような状況が頻繁に発生。 フォーク、ソフトフォーク、ソフトウェアフォーク、Git フォークと混同しないこと。 - -### ハッシュ(hash) {#hash} - -可変長サイズ入力の固定長フィンガープリントで、ハッシュ関数によって生成される ([keccak-256](#keccak-256)を参照)。 - -### ハッシュレート(hashrate) {#hash-rate} + -マイニングソフトを実行しているコンピュータが、1 秒当たりに計算するハッシュの数。 + -### HD ウォレット(HD wallet) {#hd-wallet} + -階層的決定性(HD)キーの作成と転送プロトコルを使用した[ウォレット](#wallet)。 + -[詳細は github.com を参照。](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki) - -### HD ウォレットシード(HD wallet seed) {#hd-wallet-seed} - -マスター[秘密鍵](#private-key)と HD[ウォレット](#wallet)のマスターチェーンコードの生成に使用される値。 ウォレットシードはニーモニックと呼ばれる単語の羅列で表すことができるため、秘密鍵のコピー、バックアップ、復元が容易になる。 - -### ホームステッド(homestead) {#homestead} - -2016 年 3 月に、ブロック 1,150,000 でローンチされたイーサリアムの開発第 2 段階。 + ## I {#section-i} -### インデックス {#index} - -ストレージソースへの効率的なパスを最強することによって[ブロックチェーン](#blockchain)全体からの情報のクエリを最適化するためのネットワーク構造。 - -### 取引所間クライアントアドレスプロトコル(ICAP) {#icap} - -国際銀行口座番号(IBAN)形式と部分的に互換性のあるイーサリアムアドレスの形式で、汎用的でチェックサムの付与された、相互運用可能なイーサリアムアドレスの形式を提供する。 ICAP アドレスは、(たとえば XBT、XRP、XCP のような)非管轄通貨で利用される疑似国家コードとして、「eXtended Ethereum」を意味する XE を使用する。 + -### 氷河期(Ice Age) {#ice-age} + -ブロック 200,000 で発生したイーサリアムの[ハードフォーク](#hard-fork)で、[PoS](#pos)への移行を促すために指数関数的な[ディフィカルティ](#difficulty)の増加([ディフィカルティボム](#difficulty-bomb)とも呼ばれる)を導入した。 + -### 統合開発環境(IDE) {#ide} + -一般的にはコードエディタ、コンパイラ、ランタイム、デバッガを統合したユーザーインターフェイス。 - - - 統合開発環境 - - -### 不変のデプロイコード問題(immutable deployed code problem) {#immutable-deployed-code-problem} - -[コントラクト](#smart-contract)(または[ライブラリ](#library))のコードは一度デプロイすると変更が不可能となる。 標準的なソフトウェア開発の手法では、起こりうるバグの修正や新機能を追加が可能であることを前提としているため、スマートコントラクトの開発における代表的な課題となっている。 - - - スマートコントラクトのデプロイ - - -### 内部取引(internal transaction) {#internal-transaction} - -[コントラクトアカウント](#contract-account)から別のコントラクトアカウントまたは[EOA](#eoa)に送信される[トランザクション](#transaction)([メッセージ](#message)を参照)。 + -### イシュアンス(issuance) - -報酬ブロックの提案、アテステーション、不正の告発に対して新しく Ether を発行すること。 - ## K {#section-k} -### 鍵導出関数(KDF) {#kdf} + -「パスワード伸長アルゴリズム」としても知られる。[キーストア](#keystore-file)形式で使われており、パスフレーズによる暗号化において、パスフレーズを繰り返しハッシュ化することで総当たり攻撃や辞書攻撃、レインボー攻撃から保護することができる。 + - - スマートコントラクトのセキュリティ - + -### キーストア(keystore) {#keyfile} - -イーサリアムクライアント内に存在する、すべてのアカウントの秘密鍵とアドレスのペアを保存した単一のファイル。 アカウント作成時に入力したパスワードで復号可能な、暗号化されたアカウントの秘密鍵を含む JSON 形式のテキストファイル。 - -### keccak-256 {#keccak-256} - -イーサリアムで利用されている暗号論的[ハッシュ](#hash)関数。 Keccak-256 は[SHA](#sha)-3 として標準化されている。 + ## L {#section-l} -### レイヤー 2 {#layer-2} - -イーサリアムのプロトコル上で、レイヤーによる改善に焦点を当てた開発分野。 [トランザクション](#transaction)の速度、[トランザクションフィー](#transaction-fee)の低減、トランザクションのプライバシーに関して改善を図るもの。 + - - レイヤー2 - + -### LevelDB {#level-db} + -オープンソースのオンディスクなキーバリューストアで、軽量かつ単一目的的な[ライブラリ](#library)として実装されており、多くのプラットフォーム向けバインディングが存在している。 + -### ライブラリ(library) {#library} + -payable 関数、フォールバック関数、データストレージを持たない特殊な[コントラクト](#smart-contract)。 つまり、ETH を受け取ったり、保持したり、データを保存することはできない。 ライブラリは以前にデプロイされたコードとして機能し、他のコントラクトから読み取り専用の計算を呼び出すことができる。 + - - スマートコントラクトライブラリ - - -### ライトクライアント(light client) {#light-client} - -[ブロックチェーン](#blockchain)のコピーをローカルに保存したり、ブロックや[トランザクション](#transaction)を検証したりしないイーサリアムのクライアント。 [ウォレット](#wallet)としての機能を提供し、トランザクションの作成やブロードキャストができる。 + -### LMD_GHOST {#lmd-ghost} - -イーサリアムのコンセンサスクライアントがチェーンのヘッドを特定するために使用する[フォーク選択アルゴリズム](#fork-choice-algorithm)。 LMD-GHOST は、「Latest Message Driven Greediest Heaviest Observed SubTree」の頭字語であり、チェーンの先頭がその歴史の中で[アテステーション](#attestation)の最大の蓄積を持つブロックであることを意味する。 - ## M {#section-m} -### メインネット {#mainnet} + -「メインネットワーク」の略で、メインの公開イーサリアム [ブロックチェーン](#blockchain)を指す。 本物の ETH であり、実質的な価値を持ち、そして実際に起きている結果。 [レイヤー 2](#layer-2)スケーリングソリューションについて議論するときには、レイヤー 1 とも呼ばれる ([テストネット](#testnet)も参照のこと)。 + - - イーサリアムネットワーク - + -### メモリハード(memory-hard) {#memory-hard} + -メモリハード関数とは、使用可能メモリ量が少しでも減少した場合に、速度や実行可能性が大幅に低下するプロセスのこと。 たとえば、イーサリアムのマイニングアルゴリズム[Ethash](#ethash)が挙げられる。 + -### マークルパトリシア木(Merkle Patricia trie) {#merkle-patricia-tree} + -キーバリューペアを効率的に格納するため、イーサリアムで利用されているデータ構造。 + -### メッセージ(message) {#message} + -[EVM](#evm)の内部でだけ送信され、シリアライズされることのない[内部トランザクション](#internal-transaction)。 + -### メッセージ呼び出し(message call) {#message-call} + -あるアカウントから別のアカウントに[メッセージ](#message)を伝えること。 宛先アカウントが[EVM](#evm)コー ドと関連付けられている場合、VM はそのオブジェクトの状態で起動され、メッセージが作動する。 - -### メトロポリス(Metropolis) {#metropolis} - -2017 年 10 月にローンチした、イーサリアムの開発第 3 段階。 - -### マイニング(mining) {#mining} - -先頭の任意の数のバイナリゼロが結果に含まれるまで、[ノンス](#nonce)をインクリメントしながらブロックヘッダーを繰り返しハッシュするプロセス。 新しい[ブロック](#block)がプルーフ・オブ・ワーク(PoW)[ブロックチェーン](#blockchain)に追加される。 [プルーフ・オブ・ステーク(PoS)](#pos)に移行する前まで、イーサリアムはこの方法で保護されていた。 - -### マイナー(miner) {#miner} - -新しいブロックに対して有効な[プルーフ・オブ・ワーク(PoW)](#pow)を見つけるために繰り返しパスハッシュを計算するネットワーク[ノード](#node)の一種([Ethash](#ethash)を参照)。 マイナーはもはやイーサリアムの一部ではなく、[プルーフ・オブ・ステーク(PoS)](#pos)への移行に伴い、バリデータに置き換えられた。 - - - マイニング - - -### ミント (mint) {#mint} - -ミント(Minting)は、新しいトークンを作成し、流通させて使用できるようにするプロセス。 中央当局の関与なしに新しいトークンを作成するための分散型メカニズム。 + ## N {#section-n} -### ネットワーク(network) {#network} - -イーサリアムネットワークのこと。トランザクションやブロックをすべてのイーサリアムノード(ネットワーク参加者)に伝播していくピアツーピアネットワーク。 - - - ネットワーク - - -### ネットワークハッシュレート(network hashrate) {#network-hashrate} - -マイニングネットワーク全体によって生成された集合的な[ハッシュレート](#hashrate)。 [プルーフ・オブ・ステーク(PoS)](#pos)への移行に伴い、イーサリアムでのマイニングはオフになった。 - -### 非代替性トークン(NFT) {#nft} - -「deed」としても知られる ERC-721 で導入されたトークンの標準。 NFT は追跡可能かつ取引可能だが、それぞれのトークンは一意で区別があり、ETH や[ERC-20 トークン](#token-standard)のように相互に取引することはできない。 NFT はデジタル資産や物理的な資産の所有権を表すことができる。 + - - 非代替性トークン(NFT) - - - ERC-721 非代替性トークン (NFT) 規格 - + -### ノード(node) {#node} + -ネットワークに参加するソフトウェアクライアントのこと。 + - - ノードとクライアント - - -### ノンス(nonce) {#nonce} - -暗号技術において、一度しか使われない値のこと。 アカウントのノンスは、各アカウントのトランザクションカウンターであり、リプレイ攻撃を防ぐために使用される。 + ## O {#section-o} -### オマー(アンクル)ブロック(ommer (uncle) block) {#ommer} - -プルーフ・オブ・ワークの[マイナー](#miner)が有効な[ブロック](#block)を見つけたとき、先に他のマイナーが競合するブロックを公開し、これがブロックチェーンの先端に追加されること。 古くあっても有効なブロックは*オマー*として新しいブロックに含めることができ、ブロック報酬の一部を受け取ることができる。 オマーとは、親の同生を示すジェンダーニュートラルで好ましい用語であるが、「アンクル」と呼ばれることもある。 これは、[プルーフ・オブ・ワーク(PoW)](#pow)ネットワーク時代のイーサリアムに関連していたものであり、[プルーフ・オブ・ステーク(PoS)](#pos) のイーサリアムの機能ではない。プルーフ・オブ・ステーク(PoS)では、各スロットでブロック提案者 1 人が的確に選ばれる。 - -### オプティミスティック・ロールアップ(optimistic rollup) {#optimistic-rollup} + -[レイヤー 2](#layer-2)によってトランザクションのスループットを上げ、[メインネット](#mainnet)(レイヤー 1)によってセキュリティを提供する、[不正証明](#fraud-proof)を用いたトランザクションの[ロールアップ](#rollups)。 [プラズマ](#plasma)という類似のレイヤー 2 ソリューションとは異なり、オプティミスティック・ロールアップではより複雑なトランザクションのタイプ、つまり[EVM](#evm)で実行できるすべてを処理できる。 [ゼロ知識ロールアップ](#zk-rollups)とは異なり、不正証明を用いるためレイテンシの問題がない。 + - - 楽観的ロールアップ - + -### オラクル(Oracle) {#oracle} + -オラクルとは、[ブロックチェーン](#blockchain)と現実世界を繋ぐブリッジであり、 情報を参照して[スマートコントラクト](#smart-contract)で利用できるオンチェーン[API](#api)として機能する。 - - - 神託 - + ## P {#section-p} -### パリティ(parity) {#parity} - -イーサリアムのクライアントソフトウェアの中で最も優れた相互運用可能な実装の 1 つ。 - -### ピア(peer) {#peer} - -イーサリアムのクライアントソフトウェアを実行して接続しているコンピューターで、同一のブロックチェーンのコピーを持っている。 + -### P2P(Peert To Peer)ネットワーク {#peer-to-peer-network} + -コンピューター([ピア](#peer))のネットワークで、中央集権的なサーバーベースのサービスを必要とせずに、集合的に機能を実行できる。 + -### プラズマ {#plasma} + -[オプティミスティック・ロールアップ](#optimistic-rollups)と同様、[不正証明](#fraud-proof)を用いたオフチェーンのスケーリングソリューション。 プラズマは基本的なトークンの転送やスワップなどの単純なトランザクションに限って利用可能。 + - - プラズマ - + -### 秘密鍵(シークレットキー) (private key (secret key)) {#private-key} + -イーサリアムのユーザーが、電子署名を生成することでアカウントまたはコントラクトの所有権を証明するための秘密の数字([公開鍵](#public-key)、[アドレス](#address)、[ECDSA](#ecdsa)を参照)。 + -### プライベートチェーン(private chain) {#private-chain} + -完全にプライベートなブロックチェーン。許可型のアクセスとなっており、一般公開されていないもの。 + -### プルーフ・オブ・ステーク(PoS) {#pos} + -暗号通貨のブロックチェーンプロトコルによって、分散型[コンセンサス](#consensus)を達成する方法。 トランザクションの検証に参加するため、PoS は一定量の暗号通貨(ネットワーク内のステーク)の所有権を証明するようユーザーに要求する。 - - - プルーフ・オブ・ステーク(PoS) - - -### プルーフ・オブ・ワーク(PoW) {#pow} - -発見するために大量の計算を要するデータ(証明)の一部。 - - - プルーフ・オブ・ワーク - - -### 公開鍵(public key) {#public-key} - -[秘密鍵](#private-key)から一方向関数で導出された数字。公開共有され誰でも使用でき、対応する秘密鍵で作られた電子署名を検証できる。 + ## R {#section-r} -### レシート(receipt) {#receipt} - -イーサリアムのクライアントから返されるデータで、特定の[トランザクション](#transaction)の[ハッシュ](#hash)、[ブロック](#block)ナンバー、使用された[ガス](#gas)代および[スマートコントラクト](#smart-contract)のデプロイにおいては[コントラクトアドレス](#address)を含む。 + -### 再帰可能攻撃(re-entrancy attack) {#re-entrancy-attack} + -被害者のコントラクト関数を呼び出す攻撃者のコントラクトで構成される、被害者のコントラクトの実行中に再帰的に攻撃者のコントラクトを呼び出すような攻撃。 たとえば、被害者のコントラクトの一部をスキップして残高を更新したり、引き出す金額をカウントしたりすることで、資金が盗難される可能性がある。 + - - 再帰可能(Re-entrancy) - + -### 報酬(reward) {#reward} + -[プルーフ・オブ・ワーク(PoW)](#pow)ソリューションを見つけた[マイナー](#miner)への報酬として、それぞれの新しいブロックに含まれる ether の量。 - -### 再帰長プレフィックス(RLP) {#rlp} - -イーサリアムのデベロッパーによって設計された、任意の複雑さと長さを持つオブジェクト(データ構造)をエンコードし、シリアライズする表現形式の標準。 - -### ロールアップ(rollups) {#rollups} - -[レイヤー 2](#layer-2)のスケーリングソリューションの一種で、複数のトランザクションをバッチ処理し、[イーサリアムのメインチェーン](#mainnet)に 1 つのトランザクションとして送信する。 これにより、[ガス](#gas)代を低減し、[トランザクション](#transaction)のスループットを高めることができる。 ロールアップには、スケーラビリティを得るためのセキュリティを保障する方法の違いによってオプティミスティック・ロールアップとゼロ知識ロールアップの 2 つが存在する。 - - - ロールアップ - + -### RPC {#rpc} - -**リモートプロシージャコール (RPC)**は、ネットワークの詳細を理解する必要がなく、あるプログラムがネットワーク内の別のコンピューターのプログラムからサービスをリクエストするために使用するプロトコル。 - ## S {#section-s} -### セキュアハッシュアルゴリズム(SHA) {#sha} - -米国国立標準技術研究所(NIST)が発表した暗号化ハッシュ関数のファミリー。 - -### セレニティ(Serenity) {#serenity} - -以前は「Ethereum 2.0」または「Eth2」として知られていた、スケーリングと持続可能性のためのアップグレードを開始したイーサリアムの開発段階。 - - - イーサリアムのアップグレード - - -### シリアライゼーション(serialization) {#serialization} - -データ構造をバイト列に変換するプロセス。 - -### シェアード/シェアードチェーン(shard / shard chain) {#shard} - -シェアードチェーンは、ブロックチェーン全体の個別のセクションであり、サブセットにバリデータが割り当てられる。 シェアードチェーンにより、イーサリアムのトランザクションスループットが高まり、[オプティミスティック・ロールアップ](#optimistic-rollups)や[ゼロ知識ロールアップ](#zk-rollups)などのレイヤー 2 ソリューションのデータ可用性が向上する。 + - - シャードチェーン - + -### サイドチェーン(sidechain) {#sidechain} + -スケーリングソリューションの 1 つ。独自(かつ通常は高速)の[コンセンサスルール](#consensus-rules)に従って別のチェーンを使用したもの。 サイドチェーンを[メインネット](#mainnet)に接続するためにはブリッジが必要となる。 [ロールアップ](#rollups)もサイドチェーンを利用するが、こちらは[メインネット](#mainnet)と連携して動作する。 + - - サイドチェーン - + -### 署名(signing) {#signing} + -特定の秘密鍵の保有者によってトランザクションが承認されたことを暗号によって証明すること。 + -### シングルトン(singleton) {#singleton} + -コンピュータプログラミングにおいて、1 つのインスタンスのみが存在できるオブジェクトのこと。 + -### スラッシャー(slasher) {#slasher} + -アテステーションをスキャンして、スラッシング可能な違反を検索するエンティティ。 スラッシングは、ネットワークにブロードキャストされ、次のブロック提案者は、ブロックに証拠を追加し、 悪意のあるバリデータをスラッシングすることで報酬を受け取る。 + -### スロット (slot) {#slot} + -[プルーフ・オブ・ステーク(PoS)](#pos)システムにおいて、[バリデータ](#validator)が新しいブロックを提案できる一定時間(12 秒)。 スロットが空の場合もある。 32 スロットで 1[エポック](#epoch)となる。 + - - プルーフ・オブ・ステーク(PoS) - + -### スマートコントラクト(smart contract) {#smart-contract} + -イーサリアムのコンピューティングインフラストラクチャ上で実行するプログラム。 + - - スマートコントラクトの紹介 - + -### SNARK {#snark} + -「succinct non-interactive argument of knowledge」の略で、[ゼロ知識証明](#zk-proof)の一種。 + - - ゼロ知識糾合 - + -### ソフトフォーク(soft fork) {#soft-fork} + -[ブロックチェーン](#blockchain)で、[コンセンサスルール](#consensus-rules)の変更により発生する分岐のこと。 [ハードフォーク](#hard-fork)とは逆に、ソフトフォークには後方互換性がある。新しいコンセンサスルールに従っている限り、アップグレードしたノードは、アップグレードしていないノードが作成したブロックを検証できる。 + -### Solidity {#solidity} + -JavaScript、C++、Java に似た構文を持つ手続き型(命令型)のプログラミング言語。 イーサリアムの[スマートコントラクト](#smart-contract)用の言語で、最も広範囲にわたって頻繁に使用されている。 開発者はギャビン・ウッド博士。 + - - Solidity - + -### Solidity インラインアセンブリ(Solidity inline assembly) {#solidity-inline-assembly} - -[Solidity](#solidity)のなかに埋め込まれた[EVM](#evm)アセンブリ言語。 Solidity は特定の操作を容易に記述するためにインラインアセンブリをサポートしている。 - -### スプリニアスドラゴン(Spurious Dragon) {#spurious-dragon} - -ブロック 2,675,000 で発生したイーサリアムブロックチェーンの[ハードフォーク](#hard-fork)で、大量の DoS の攻撃ベクタとクリアな状態に対応([タンジェリンホイッスル](#tangerine-whistle)を参照)。 また、リプレイ攻撃に対する保護メカニズムも組み込まれた([ノンス](#nonce)を参照)。 - -### ステーブルコイン(stablecoin) {#stablecoin} - -他の資産の価値にペッグされた価値を持つ[ERC-20 トークン](#token-standard)。 ドルのような法定通貨や、金のような貴金属、ビットコインのような他の暗号通貨に担保されたステーブルコインがある。 - - - ETHはイーサリアムの唯一の暗号ではありません - - -### ステーキング {#staking} - -バリデータとなり[ネットワーク](#network)を担保するために一定量の[ETH](#ether)(ステーク)を預け入れること。 バリデータは、[トランザクション](#transaction)を検証し、[PoS](#pos)コンセンサスモデルの下で[ブロック](#block)を提案する。 ステーキングによって、ネットワークの利益を最優先に考えて行動する経済的インセンティブが得られる。 [バリデータ](#validator)の職務を遂行すると報酬が得られるが、職務を怠ると大量の ETH を失うことになる。 - - - ETHをステーキングし、イーサリアムのバリデータになる - - -### ステーキングプール(staking pool) {#staking-pool} - -複数のイーサリアムステーカーの ETH を合計し、バリデータキーのセットを有効にするために必要な 32ETH に到達するために使用される。 ノードオペレーターは、これらのキーを使用しコンセンサスに参加する。 [ブロック報酬](#block-reward)は、貢献しているステーカー間で分配される。 ステーキングプールや委任ステーキングは、イーサリアムプロトコルネイティブではないが、コミュニティによって多数のソリューションが作成されている。 - - - ステーキングプール - - -### STARK {#stark} - -「scalable transparent argument of knowledge」の略で、[ゼロ知識証明](#zk-proof)の一種。 - - - ゼロ知識糾合 - - -### ステート(state) {#state} - -ブロックチェーン上の特定の時点における全ての残高とデータのスナップショット。通常は特定のブロックの状態を指す。 - -### ステートチャンネル(state channels) {#state-channels} - -参加者間でチャンネルが設定され、自由かつ安価に取引できる[レイヤー 2](#layer-2)のソリューション。 チャンネルを設定、閉じるための[トランザクション](#transaction)だけが[メインネット](#mainnet)に送信される。 非常に高いトランザクションスループットを実現するものの、事前に参加者の数を把握し、資金をロックアップすることに依存する。 - - - ステートチャンネル - - -### スーパーマジョリティ(supermajority) {#supermajority} - -スーパーマジョリティとは、イーサリアムを保護するためにステーキングされた ETH の総量の 2/3(66%)を超える量を指す用語。 ビーコンチェーンでブロックを[確定](#finality)するには、スーパーマジョリティの投票が必要となる。 - -### 同期(syncing) {#syncing} - -最新バージョンのブロックチェーン全体をノードにダウンロードするプロセス。 - -### 同期委員会(sync committee) {#sync-committee} - -同期委員会は、[バリデータ](#validator)からランダムに選択されたグループで、約 27 時間ごとに更新され、 有効なブロックヘッダに署名を追加することを目的としている。 同期委員会は、[ライトクライアント](#light-client)がバリデータセット全体にアクセスせずにブロックチェーンの先頭を追跡できるようにする。 - -### szabo {#szabo} - -[ether](#ether)の単位。 1 szabo = 1012 [wei](#wei)、106 szabo = 1 ether。 + ## T {#section-t} -### タンジェリンホイッスル(Tangerine Whistle) {#tangerine-whistle} - -ブロック 2,463,000 で発生したイーサリアムブロックチェーンの[ハードフォーク](#hard-fork)で、特定の I/O 集中型オペレーションの[ガス](#gas)計算を変更し、低いガスコストを悪用したサービス拒否攻撃から蓄積した状態を消去するために発生したもの。 - -### 最終合計難易度(TTD) {#terminal-total-difficulty} - -合計難易度は、ブロックチェーンのある特定の時点までのすべてのブロックの Ethash の採掘難易度の合計。 最終合計難易度は、実行クライアントがマイニングとブロックゴシップ機能を停止し、ネットワークがプルーフ・オブ・ステーク(PoS)に移行するきっかけとして使われた合計難易度の特定の値を指す。 + -### テストネット(testnet) {#testnet} + -テストネットワークの略で、イーサリアムのメインネットワーク([メインネット](#mainnet)参照)の動作をシミュレートするためのネットワーク。 + - - テストネット - + -### トークン(token) {#token} + -イーサリアムブロックチェーン上のスマートコントラクトで定義された取引可能な仮想商品。 + -### トークン標準(token standard) {#token-standard} + -ERC-20 提案によって導入された、これは代替性トークンのための標準化された[スマートコントラクト](#smart-contract)構造を提供。 [NFT](#nft)とは異なり、同一コントラクトからのトークンであれば、追跡、取引、交換が可能。 + - - ERC-20トークン規格 - - -### トランザクション(transaction) {#transaction} - -特定の[アドレス](#address)を対象に、発信元[アカウント](#account)によって署名されたイーサリアムブロックチェーンにコミットされたデータ。 トランザクションには、そのトランザクションの[ガスリミット](#gas-limit)などのメタデータが含まれている。 - - - 処理 - - -### トランザクションフィー(transaction fee) {#transaction-fee} - -イーサリアムネットワークを使用するたびに支払う必要がある手数料。 たとえば、トークンの交換や収集品の購入などで、[ウォレット](#wallet)から資金を送ったり、[Dapp](#dapp)とやり取りをすることなどが挙げられる。 これはサービス料のようなものであり、 料金はネットワークの混雑状況によって変動する。 トランザクション処理を担当する[バリデータ](#validator)が、より高い手数料のトランザクションを優先する傾向があり、その結果、混雑すると価格が上昇する。 - -技術的なレベルでは、トランザクションフィーは、トランザクションに必要な[ガス](#gas)の量に関係する。 - -トランザクションフィーの削減が現在注目されているテーマとなっている。 [レイヤー 2](#layer-2)を参照。 - -### トラストレス(trustlessness) {#trustlessness} - -第三者の信用なしにトランザクションを仲介するネットワークの能力。 - -### チューリング完了(Turing complete) {#turing-complete} - -イギリスの数学者兼コンピュータ科学者であるアラン・チューリングにちなんで名付けられた概念。データ操作規則のシステム(コンピュータの命令セット、プログラミング言語、セル・オートマトンなど)が、あらゆるチューリング機械のシミュレーションに使用できる場合、「チューリング完了」または、「計算普遍」であると呼ばれる。 + ## V {#section-v} -### バリデータ(validator) {#validator} - -[プルーフ・オブ・ステーク(PoS)](#pos)システムにおいて、データの保存、トランザクションの処理、ブロックチェーンへの新しいブロックの追加を行う[ノード](#node)。 バリデータを有効にするためには、32ETH を[ステーク](#staking)できる必要がある。 - - - プルーフ・オブ・ステーク - - - イーサリアムのステーキング - - -### バリデータのライフサイクル(validator lifecycle) {#validator-lifecycle} - -バリデータが存在できる状態のシーケンス。 たとえば、 + -- deposited: バリデータが最低 32 ETH を[デポジットコントラクト](#deposit-contract)に入金している -- pending: バリデータがアクティブ化キューの中で、既存のバリデータがネットワークに投票するのを待っている -- active: 現在ブロックのアテステーションと提案を行っている -- slashing: バリデータが不正な動作をしており、スラッシングされている -- exiting: 自発的に終了、もしくは追放されたため、バリデータにネットワーク終了のフラグが立てられている。 + -### 有効性証明(validity proof) {#validity-proof} + -特定の[レイヤー 2](#layer-2)におけるセキュリティモデルで、速度を上げるために複数のトランザクションを 1 つのバッチに[ロールアップ](/#rollups)し、イーサリアムに 1 つのトランザクションとして送信する。 トランザクションの計算はオフチェーンで行われ、その有効性の証明とともにメインチェーンに公開される。 この方法は、セキュリティを維持しつつ処理可能なトランザクションの量を増加させる。 [ロールアップ](#rollups)の中には、[不正証明](#fraud-proof)を利用するものもある。 + - - ゼロ知識糾合 - - -### Validium {#validium} - -トランザクションのスループットを向上させるために[有効性証明](#validity-proof)を使用するオフチェーンソリューション。 [ゼロ知識ロールアップ](#zk-rollup)とは異なり、Validium はデータをレイヤー 1 の[メインネット](#mainnet)に保存しない。 - - - バリディアム - - -### Vyper {#vyper} - -Python に似た構文を持つ高水準プログラミング言語。 純粋関数型言語に近づくことを目標としている。 ヴィタリック・ブテリンによって開発された。 - - - Vyper - + ## W {#section-w} -### ウォレット(wallet) {#wallet} - -[秘密鍵](#private-key)を保持するソフトウェア。 イーサリアムの[アカウント](#account)へのアクセスおよび操作、または[スマートコントラクト](#smart-contract)とやり取りするために使用する。 鍵をウォレットに保管する必要はなく、セキュリティを向上させるためにオフラインストレージ(たとえば、メモリーカードや紙)から取得することもできる。 ウォレットという名前ではあるが、実際にコインやトークンを保持することはない。 - - - イーサリアムウォレット - + -### Web3 {#web3} + -Web の 3 番目のバージョン。 ギャビン・ウッド博士によって最初に提案されたもので、中央集権的に所有・管理されるアプリケーションから、分散型プロトコルで構築されたアプリケーションに移行するという Web アプリケーションの新しいビジョンと焦点を示している。 ([dapp](#dapp)を参照) + - - Web2とWeb3の比較 - - -### wei {#wei} - -[イーサ](#ether)の最小単位。 1018 wei = 1 ether. + ## Z {#section-z} -### ゼロアドレス(zero address) {#zero-address} - -全てがゼロで構成されたイーサリアムアドレスであり、所有された流通トークンを削除するためのアドレスとして頻繁に使用される。 burn()メソッドによってスマートコントラクトのインデックスから形式的に削除されたトークンと、このアドレスに送信されたトークンは区別される。 - -### ゼロ知識証明(zero-knowledge proof) {#zk-proof} - -ゼロ知識証明とは、ある命題が真であることを、追加の情報を伝えることなく証明することができる暗号方式である。 - - - ゼロ知識糾合 - - -### ゼロ知識ロールアップ(zero-knowledge rollup) {#zk-rollup} + -[レイヤー 2](#rollups)によってトランザクションのスループットを高め、[メインネット](#validity-proof)(レイヤー 1) によってセキュリティを提供する、[有効性証明](#layer-2)を用いたトランザクションの[ロールアップ](#mainnet)。 [オプティミスティック・ロールアップ](#optimistic-rollups)のように複雑なトランザクションを扱うことはできないが、トランザクションは送信された段階で有効であることが確定し、遅延が発生することはない。 + - - ゼロ知識ロールアップ - + ## 出典 {#sources} -_[『マスタリング・イーサリアム』](https://github.com/ethereumbook/ethereumbook)([アンドレアス・M・ アントノプロス、ギャビン・ウッド](https://ethereumbook.info)著)の一部より CC-BY-SA のもと提供されました。_ +_一部は[Andreas M. Antonopoulos、Gavin Wood](https://aantonop.com/books/mastering-ethereum)著の[Mastering Ethereum](https://github.com/ethereumbook/ethereumbook)より、CC-BY-SAライセンスの下で提供されています_ -## 本ページへの貢献 {#contribute-to-this-page} +## このページに貢献する {#contribute-to-this-page} -不足している情報はありませんか? 誤情報はありませんか? GitHub でこちらの用語集に貢献いただき、改善にご協力ください。 +不足している情報はありませんか? 誤った情報はありませんか? GitHubでこの用語集の改善にご協力ください! -[貢献方法についての詳細を確認](/contributing/adding-glossary-terms) +[貢献する方法の詳細を見る](/contributing/adding-glossary-terms) diff --git a/public/content/translations/ja/governance/index.md b/public/content/translations/ja/governance/index.md index 2d051cad963..449cb875601 100644 --- a/public/content/translations/ja/governance/index.md +++ b/public/content/translations/ja/governance/index.md @@ -1,10 +1,10 @@ --- -title: イーサリアムのガバナンス -description: イーサリアムに関する決定がどのように行われるかについてのご紹介 +title: "イーサリアムのガバナンス" +description: "イーサリアムに関する決定がどのように行われるかについてのご紹介" lang: ja --- -# イーサリアムのガバナンスの概要 {#introduction} +# イーサリアムのガバナンス入門 {#introduction} _イーサリアムは誰かに所有されるものではないため、イーサリアムのこれまでの変更と今後の変更に関する決定はどのように行われるのでしょうか? イーサリアムのガバナンスとは、そのような意思決定を可能にするプロセスのことです._ @@ -22,15 +22,15 @@ _イーサリアムは誰かに所有されるものではないため、イー イーサリアムのガバナンスは、プロトコルを変更するためのプロセスです。 ここで重要なのは、このプロセスは、人々やアプリケーションがプロトコルをどのように使用するかには関係しないということです。イーサリアムはパーミッションレスです。 世界のどこからでも、誰でもオンチェーン・アクティビティに参加できます。 誰がアプリケーションを構築したり、トランザクションを送信したりできるかどうかのルールは設定されていません。 ただし、分散型アプリケーションが実行されるコアプロトコルへの変更を提案するプロセスが存在します。 非常に多くの人々がイーサリアムの安定性に依存しているため、イーサリアムへの変更が安全で広くコミュニティに支持されるように、社会的および技術的プロセスを含めて、コアの変更には非常に高いハードルが設定されています. -### オンチェーンとオフチェーンのガバナンス比較 {#on-chain-vs-off-chain} +### オンチェーン vs オフチェーンガバナンス {#onchain-vs-offchain} ブロックチェーン技術では、オンチェーンガバナンスと呼ばれる新しいガバナンス機能が利用可能です。 オンチェーンガバナンスとは、提案されたプロトコルの変更が、通常はガバナンストークンの保有者であるステークホルダーの投票によって決定され、投票はブロックチェーン上で行われます。 一部のオンチェーンガバナンスの形態では、提案されたプロトコルの変更は既にコードとして記述され、ステークホルダーが変更を承認するためにトランザクションに署名すると、変更が自動的に実装されます。 -反対のアプローチであるオフチェーンガバナンスでは、プロトコル変更の決定は、社会的な議論による非公式なプロセスで行われ、承認されればコードで実装されます。 +反対のアプローチであるオフチェーンガバナンスでは、プロトコル変更の決定は、社会的な議論による非公式なプロセスで行われ、もし承認された場合、その内容がコードとして実装されます。 -**イーサリアムのガバナンスはオフチェーン**で行われており、そのプロセスには様々なステークホルダーが関わっています。 +**イーサリアムのガバナンスはオフチェーンで行われており**、そのプロセスには様々なステークホルダーが関わっています。 -_プロトコルレベルではイーサリアムのガバナンスはオフチェーンですが、分散型自律組織(DAO)などイーサリアム上に構築された多くのユースケースではオンチェーンのガバナンスを使用しています。_ +_プロトコルレベルではイーサリアムのガバナンスはオフチェーンですが、DAOなどイーサリアム上に構築された多くのユースケースではオンチェーンのガバナンスを使用しています。_ 分散型自律組織(DAO)の詳細 @@ -38,25 +38,25 @@ _プロトコルレベルではイーサリアムのガバナンスはオフチ -## ステークホルダー {#who-is-involved} +## 。 {#who-is-involved} -[イーサリアムコミュニティ](/community/)には様々なステークホルダーがおり、それぞれがガバナンスプロセスでの役割を果たしています。 プロトコルから最も遠いステークホルダーから始めて、徐々に近づいて見ると、次のようになります。 +[イーサリアムコミュニティ](/community/)には様々なステークホルダーが存在し、それぞれがガバナンスプロセスで役割を担っています。 プロトコルから最も遠いステークホルダーから始めて、徐々に近づいて見ると、次のようになります。 -- **イーサ所有者**: 任意の額のETHの保有者。 [ETHの詳細](/what-is-ether/) -- **アプリケーションユーザー**: イーサリアムブロックチェーン上のアプリケーションを利用するユーザー。 -- **アプリケーション/ツールデベロッパー**: イーサリアムブロックチェーン上で実行されるアプリケーション(分散型金融、非代替性トークンなど)、またはイーサリアムとやり取りするためのツール(ウォレット、テストスイートなど)のデベロッパー。 [分散型アプリ(Dapp)の詳細](/apps/) -- **ノード運用者**: ブロックやトランザクションを伝播させるノードを実行し、見つけた不正なトランザクションやブロックを拒否します。 [ノードの詳細](/developers/docs/nodes-and-clients/) -- **EIP起草者**: 起草者は、イーサリアムプロトコルの変更を、イーサリアム改善提案(EIP)の形で提案します。 [EIPの詳細](/eips/) -- **バリデータ**: 新しいブロックをイーサリアムブロックチェーンに追加できるノードを実行しています。 -- **プロトコルデベロッパー** (別名 「コアデベロッパー」) さまざまなイーサリアム実装を維持する人々のことです (例:実行レイヤではgo-ethereum、Nethermind、Besu、Erigon、Reth、またはコンセンサスレイヤではPrysm、Lighthouse、Nimbus、Teku、Lodestarなど) 。 [イーサリアムクライアントの詳細](/developers/docs/nodes-and-clients/) +- **イーサ保有者**: 任意の額のETHを保有している人々。 [ETHの詳細](/what-is-ether/)。 +- **アプリケーションユーザー**: イーサリアムブロックチェーン上のアプリケーションを操作する人々。 +- **アプリケーション/ツールデベロッパー**: イーサリアムブロックチェーン上で実行されるアプリケーション(例: DeFi、NFTなど)を作成する人々です。 また、イーサリアムと対話するためのツール(例: ウォレット、テストスイートなど)も構築します。 [dappsの詳細](/apps/)。 +- **ノード運用者**: ブロックやトランザクションを伝播させるノードを実行し、遭遇した無効なトランザクションやブロックを拒否する人々。 [ノードの詳細](/developers/docs/nodes-and-clients/)。 +- **EIP起草者**: イーサリアム改善提案(EIP)の形でイーサリアムプロトコルの変更を提案する人々。 [EIPの詳細](/eips/)。 +- **バリデータ**: イーサリアムブロックチェーンに新しいブロックを追加できるノードを実行する人々。 +- **プロトコルデベロッパー**(別名 「コアデベロッパー」): イーサリアムの様々な実装(実行レイヤーのgo-ethereum、Nethermind、Besu、Erigon、Reth、またはコンセンサスレイヤーのPrysm、Lighthouse、Nimbus、Teku、Lodestar、Grandineなど)をメンテナンスする人々。 [イーサリアムクライアントの詳細](/developers/docs/nodes-and-clients/)。 -_注: どの個人もこれらのグループの複数に参加できます(たとえば、プロトコルデベロッパーはイーサリアム改善提案チャンピオンを兼ね、またビーコンチェーンバリデータを行い、同時に分散型金融アプリケーションも使用できます)。 ただ、概念を明確にするために、これらを区別するのが最も簡単です。_ +_注: どの個人もこれらのグループの複数に参加できます(たとえば、プロトコルデベロッパーがEIPを主導し、ビーコンチェーンのバリデータを実行し、DeFiアプリケーションを使用することも可能です)。 ただし、概念を明確にするために、これらを区別するのが最も簡単です。_ ## イーサリアム改善提案(EIP)とは {#what-is-an-eip} -イーサリアムのガバナンスで使われる重要なプロセスの1つに、**イーサリアム改善提案**があります。 イーサリアム改善提案(EIP)とは、イーサリアムの新しい機能やプロセスを定める標準であり、 イーサリアムコミュニティの誰もが作成することができます。 EIPの作成、ピアレビュー、ガバナンスへの参加に興味をお持ちの場合は、次を参照してください。 +イーサリアムのガバナンスで使われる重要なプロセスの1つに、\*\*イーサリアム改善提案(EIP)\*\*の提案があります。 イーサリアム改善提案(EIP)とは、イーサリアムの新しい機能やプロセスを定める標準であり、 イーサリアムコミュニティの誰もが作成することができます。 EIPの作成、ピアレビュー、ガバナンスへの参加に興味をお持ちの場合は、次を参照してください。 イーサリアム改善提案(EIP)の詳細 @@ -64,13 +64,13 @@ _注: どの個人もこれらのグループの複数に参加できます(た -## 公式プロセス {#formal-process} +## 正式なプロセス {#formal-process} イーサリアムのプロトコルを変更するための公式プロセスは以下の通りです。 -1. **コア・イーサリアム改善提案**: [EIP-1](https://eips.ethereum.org/EIPS/eip-1#core-eips)に記述されているように イーサリアムに変更を正式に提案するには、まずコア・イーサリアム改善提案で詳述することです。 受け入れられると、プロトコルデベロッパーが実装するイーサリアム改善提案(EIP)の公式の仕様になります。 +1. **コアEIPの提案**: [EIP-1](https://eips.ethereum.org/EIPS/eip-1#core-eips)に記載されているように、イーサリアムへの変更を正式に提案するための最初のステップは、コアEIPでその詳細を説明することです。 受け入れられると、プロトコルデベロッパーが実装するイーサリアム改善提案(EIP)の公式の仕様になります。 -2. **プロトコルデベロッパーへイーサリアム改善提案(EIP)の提示**: コミュニティの意見を集めたコア・イーサリアム改善提案の作成後、プロトコルデベロッパーにそれを提示します。 [全コア開発コール](https://github.com/ethereum/execution-specs/tree/master/network-upgrades#getting-the-considered-for-inclusion-cfi-status)に提示し、議論します。 [イーサリアム・マジシャンズ・フォーラム](https://ethereum-magicians.org/)または[イーサリアムR&Dディスコード](https://discord.gg/mncqtgVSVw) で、議論が既に並行して行われている場合があります。 +2. **EIPをプロトコルデベロッパーに提示**: コミュニティからのインプットを集めたコアEIPを作成したら、プロトコルデベロッパーに提示する必要があります。 これは、[AllCoreDevs call](https://github.com/ethereum/execution-specs/tree/master/network-upgrades#getting-the-considered-for-inclusion-cfi-status)での議論のために提案することで行うことができます。 [Ethereum Magician's forum](https://ethereum-magicians.org/)や[Ethereum R&D Discord](https://discord.gg/mncqtgVSVw)で、すでに非同期でいくつかの議論が行われている可能性があります。 > この段階で起こり得る結果は、次のようなものがあります。 @@ -78,49 +78,49 @@ _注: どの個人もこれらのグループの複数に参加できます(た > - 技術的な変更をリクエストする > - 優先順位が低い場合や、開発労力に比べて改善効果が十分に大きくない場合には、却下される -3. **最終提案に向けた反復作業**: すべての関連するステークホルダーからのフィードバックを受けた後、セキュリティを向上させたり、さまざまなユーザーのニーズを満たすために、おそらく最初の提案に変更を加える必要がでてくるでしょう。 イーサリアム改善提案(EIP)に必要と思われる変更をすべて反映させたら、プロトコルデベロッパーに再度提示する必要があります。 その後、次のステップに進む、または新たな懸念事項が出てきて、提案を再度繰り返し行う必要が出てきます。 +3. **最終提案に向けた反復**: 関連するすべてのステークホルダーからフィードバックを受けた後、セキュリティを向上させたり、さまざまなユーザーのニーズをよりよく満たすために、最初の提案に変更を加える必要が出てくるでしょう。 イーサリアム改善提案(EIP)に必要と思われる変更をすべて反映させたら、プロトコルデベロッパーに再度提示する必要があります。 その後、次のステップに進む、または新たな懸念事項が出てきて、提案を再度繰り返し行う必要が出てきます。 -4. **ネットワーク・アップグレードに含まれる**: イーサリアム改善提案(EIP)が承認され、テストされ、実装されたと仮定すると、ネットワーク・アップグレードの一部に含まれます。 ネットワーク・アップグレードには高い調整コストがかかるため(全員が同時にアップグレードする必要がある)、イーサリアム改善提案(EIP)は一般的にアップグレードのタイミングにまとめられます。 +4. **ネットワークアップグレードに含まれるEIP**: EIPが承認、テスト、実装されると、ネットワークアップグレードの一部としてスケジュールされます。 ネットワーク・アップグレードには高い調整コストがかかるため(全員が同時にアップグレードする必要がある)、イーサリアム改善提案(EIP)は一般的にアップグレードのタイミングにまとめられます。 -5. **ネットワーク・アップグレード有効化**: ネットワーク・アップグレードが有効化されると、イーサリアム改善提案(EIP)はイーサリアムネットワークで稼働します。 _注: ネットワーク・アップグレードは通常、イーサリアムメインネットで有効化される前にテストネットで行われます_。 +5. **ネットワークアップグレードの有効化**: ネットワークアップグレードが有効化されると、EIPはイーサリアムネットワーク上で稼働します。 _注: ネットワークアップグレードは通常、イーサリアムメインネットで有効化される前にテストネットで有効化されます。_ このフローは非常に簡略化されていますが、イーサリアム上でプロトコルの変更を有効にするための重要な手順の概要を示しています。 では、このプロセスにおける非公式な要素を見てみましょう。 -## 非公式のプロセス {#informal-process} +## 非公式なプロセス {#informal-process} -### 過去の作業についての理解 {#prior-work} +### 既存の作業の理解 {#prior-work} -イーサリアム改善提案チャンピオンは、イーサリアム改善提案(EIP)を作成する前に、イーサリアムメインネットでの展開を真剣に検討できるよう、過去の作業や提案をよく理解しておく必要があります。 これにより、過去に拒否されていない、新しい提案をもたらすことができます。 過去のイーサリアム改善提案(EIP)を調べるには、主に[イーサリアム改善提案(EIP)リポジトリ](https://github.com/ethereum/EIPs)、[ イーサリアム・マジシャンズ](https://ethereum-magicians.org/)、[etthresear.ch](https://ethresear.ch/)の3つの場所があります。 +イーサリアム改善提案チャンピオンは、イーサリアム改善提案(EIP)を作成する前に、イーサリアムメインネットでの展開を真剣に検討できるよう、過去の作業や提案をよく理解しておく必要があります。 これにより、過去に拒否されていない、新しい提案をもたらすことができます。 これを調査する主な3つの場所は、[EIPリポジトリ](https://github.com/ethereum/EIPs)、[Ethereum Magicians](https://ethereum-magicians.org/)、[ethresear.ch](https://ethresear.ch/)です。 ### ワーキンググループ {#working-groups} -最初のドラフトのイーサリアム改善提案は、編集や変更なしにイーサリアムのメインネットに実装されることはまずありません。 一般的に、イーサリアム改善提案チャンピオンは、プロトコルデベロッパーのサブセットと協力して、提案の具体化、実装、テスト、反復、提案の最終化を行います。 これまでの事例を見ても、これらのワーキンググループには数ヶ月(時には数年も!)の作業が必要でした。 同様に、このような変更を行うイーサリアム改善提案チャンピオンは、エンドユーザーからのフィードバックを収集し、展開上のリスクを軽減するために、関連するアプリケーション/ツールデベロッパーを早期の段階で参加させる必要があります。 +最初のドラフトのイーサリアム改善提案は、編集や変更なしにイーサリアムのメインネットに実装されることはまずありません。 一般的に、イーサリアム改善提案チャンピオンは、プロトコルデベロッパーのサブセットと協力して、提案の具体化、実装、テスト、反復、提案の最終化を行います。 歴史的に、これらのワーキンググループには数ヶ月(時には数年!) の作業が必要でした。 同様に、このような変更を行うイーサリアム改善提案チャンピオンは、エンドユーザーからのフィードバックを収集し、展開上のリスクを軽減するために、関連するアプリケーション/ツールデベロッパーを早期の段階で参加させる必要があります。 -### コミュニティコンセンサス {#community-consensus} +### コミュニティのコンセンサス {#community-consensus} ニュアンスを最小限にとどめた分かりやすい技術的改善のEIPがある一方、より複雑でさまざまな形でさまざまな利害関係者に影響を与えるトレードオフが伴うEIPもあります。 つまり、コミュニティ内で議論の分かれるEIPも存在するということです。 争点となる提案をどのように扱うか、明確なプレイブックはありません。 これは、イーサリアムの分散型設計による結果であり、どのステークホルダーグループも力ずくで他のグループを強制することはできません。プロトコルの開発者はコードの変更を実装しないことを選択でき、ノードオペレーターは最新のイーサリアムクライアントを実行しないことを選択でき、アプリケーションチームとユーザーはチェーン上でのトランザクションを行わないことを選択できるのです。 プロトコルデベロッパーは、ネットワークのアップグレードを強制する手段を持たないため、通常、議論がコミュニティ全体の利益を上回ってしまうようなEIPの実装を避けるでしょう。 -イーサリアム改善提案(EIP)チャンピオンは、すべての関連するステークホルダーのフィードバックを求めることが期待されています。 もし、あなたが論争中のイーサリアム改善提案(EIP)のチャンピオンになったとしたら、自分の提案に対する合意を得るために、反対意見に対処する必要があります。 イーサリアムコミュニティの規模と多様性を考えると、コミュニティの合意を測るために使用できる単一の指標(コイン投票など)はなく、イーサリアム改善提案(EIP)チャンピオンは提案の状況に応じて柔軟に対処することが求められます。 +イーサリアム改善提案(EIP)チャンピオンは、すべての関連するステークホルダーのフィードバックを求めることが期待されています。 もし、あなたが論争中のイーサリアム改善提案(EIP)のチャンピオンになったとしたら、自分の提案に対する合意を得るために、反対意見に対処する必要があります。 イーサリアムコミュニティの規模と多様性を考えると、コミュニティのコンセンサスを測るために使用できる単一の指標(コイン投票など)は存在せず、EIPチャンピオンは提案の状況に適応することが期待されます。 イーサリアムネットワークのセキュリティだけでなく、プロトコルデベロッパーは、アプリケーション/ツールデベロッパーやアプリケーションユーザーの価値を重視してきました。これは、アプリケーション/ツールデベロッパーやアプリケーションユーザーがイーサリアムを使用して開発することが他のステークホルダーにとってエコシステムを魅力的なものにするという観点によるものです。 さらに、イーサリアム改善提案(EIP)は、異なるチームによって管理されているすべてのクライアントに導入される必要があります。 そのため、このプロセスの一環として、変更が価値あるものであり、それがエンドユーザーを助けたり、セキュリティ問題を解決するものであることを、プロトコルデベロッパーの複数のチームに納得させることが大切です。 -## 意見の不一致への対処 {#disagreements} +## 意見の不一致への対応 {#disagreements} さまざまな動機や信念を持った多くのステークホルダーがいるため、意見の相違が生じることも少なくありません。 一般的に、意見の相違は、問題の根本を理解し、誰もが意見を述べることができるように、パブリックフォーラムでの長時間の議論の中で処理されます。 一般的には、一方のグループが譲歩するか、あるいは望ましい中間妥協案になります。 1つのグループが強く反対しているのであれば、特定の変更を強制すると、チェーン・スプリットにつながる可能性があります。 チェーン・スプリットとは、一部の関係者がプロトコルの変更を抗議した結果、互換性のない異なるバージョンのプロトコルが動作し、そこから2つの異なるブロックチェーンが生まれることです。 -### The DAOフォーク(DAO: 分散型自律組織) {#dao-fork} +### DAOフォーク {#dao-fork} -フォークとは、ネットワークに大きな技術的なアップグレードや変更が必要となり、プロトコルの「ルール」を変更することです。 [イーサリアムクライアント](/developers/docs/nodes-and-clients/)は、新しいフォークルールを実装するためにソフトウェアをアップデートする必要があります。 +フォークとは、ネットワークに大きな技術的なアップグレードや変更が必要となり、プロトコルの「ルール」を変更することです。 [イーサリアムクライアント](/developers/docs/nodes-and-clients/)が新しいフォークルールを実装するには、ソフトウェアのアップデートが必要となります。 -The DAOフォークは、周到に脆弱性を突いた[2016年のThe DAO攻撃](https://www.coindesk.com/learn/understanding-the-dao-attack)で360万ETH以上の[分散型自律組織(DAO)](/glossary/#dao)コントラクトが流出した事件を受けたものです。 このフォークにより、欠陥をもったコントラクトから新しいコントラクトに資金が転送され、ハッキングでETHを失った人が回収できるようになりました。 +DAOフォークは、[2016年のDAO攻撃](https://www.coindesk.com/learn/understanding-the-dao-attack)への対応でした。この攻撃では、安全でなかった[DAO](/glossary/#dao)のコントラクトから、ハッキングによって360万ETH以上が流出しました。 このフォークにより、欠陥をもったコントラクトから新しいコントラクトに資金が転送され、ハッキングでETHを失った人が回収できるようになりました。 -この行動指針はイーサリアムコミュニティの投票で行われました。 ETH保有者は、 [投票プラットフォーム](https://web.archive.org/web/20170620030820/http://v1.carbonvote.com/)でトランザクションを通じて投票することができました。 フォークの実行は、投票の85%以上に支持されました。 +この行動指針はEthereumコミュニティの投票で行われました。 どのETH保有者も、[投票プラットフォーム](https://web.archive.org/web/20170620030820/http://v1.carbonvote.com/)上のトランザクションを介して投票することができました。 フォークの実行は、投票の85%以上に支持されました。 ここで重要なのは、プロトコルがハッキングを元に戻すためにフォークしたものの、フォークを決定する際の投票の重要性については、いくつかの理由から議論の余地があるということです。 @@ -128,7 +128,7 @@ The DAOフォークは、周到に脆弱性を突いた[2016年のThe DAO攻撃] - ほとんどの人が投票が行われていることを知らなかった - 投票がETHの保有者のみを代表するものであり、システムの他の参加者を代表するものではなかった -コミュニティの一部がフォークを拒否したのは、The DAO事件がプロトコルの欠陥ではないと考えたことが主な理由です。 その後、彼らは[イーサリアムクラシック](https://ethereumclassic.org/)を形成しました。 +コミュニティの一部がフォークを拒否したのは、The DAO事件がプロトコルの欠陥ではないと考えたことが主な理由です。 彼らは[Ethereum Classic](https://ethereumclassic.org/)を結成するに至りました。 現在、イーサリアムコミュニティでは、システムの信頼できる中立性を維持するために、コントラクトのバグや資金の損失の場合には介入しないという方針を採用しています。 @@ -138,7 +138,7 @@ The DAOハッキング事件をもっと見る -### フォークの効用 {#forking-utility} +### フォークの有用性 {#forking-utility} イーサリアムとイーサリアムクラシックは、健全なフォークの良い例です。 2つのグループは、いくつかの基本的な価値観においてお互いに強く意見を異にしていましたが、それぞれの行動方針を追求するのは、リスクに見合う価値があると考えました。 @@ -146,13 +146,13 @@ The DAOハッキング事件をもっと見る -## ビーコンチェーンガバナンス {#beacon-chain} +## ビーコンチェーンのガバナンス {#beacon-chain} イーサリアムガバナンスプロセスでは、スピードや効率性と、オープン性や包括性がトレードオフになることがよくあります。 ビーコンチェーンの開発を加速させるために、プルーフ・オブ・ワークのイーサリアムネットワークとは別に立ち上げられ、独立したガバナンスが行われています。 仕様と開発実装は常に完全にオープンソースであったものの、上記で説明したアップデートの提案に使用される正式なプロセスは採用されていませんでした。 プロセスを省略することにより、研究者と実装者が迅速に変更点を特定し、合意することができました。 -ビーコンチェーンが2022年9月15日にイーサリアムの実行レイヤーと統合され、マージは[パリスネットワークのアップグレード](/ethereum-forks/#paris)の一環として完了しました。 提案 [EIP-3675](https://eips.ethereum.org/EIPS/eip-3675)は「ラストコール」から「ファイナル」に変更され、プルーフ・オブ・ステークへの移行が完了しました +2022年9月15日にビーコンチェーンがイーサリアムの実行レイヤーとマージされた際、[Parisネットワークアップグレード](/ethereum-forks/#paris)の一環としてマージが完了しました。 提案[EIP-3675](https://eips.ethereum.org/EIPS/eip-3675)は「最終確認」から「最終版」に変更され、プルーフ・オブ・ステークへの移行が完了しました。 マージの詳細 @@ -160,23 +160,25 @@ The DAOハッキング事件をもっと見る -## 参加方法 {#get-involved} +## 参加方法 参加する {#get-involved} -- [イーサリアム改善提案(EIP)の提案](/eips/#participate) -- [現在の提案についての議論](https://ethereum-magicians.org/) -- [R&Dディスカッションへの参加](https://ethresear.ch/) -- [イーサリアムR&Dディスコードへの参加](https://discord.gg/mncqtgVSVw) -- [ノードの運用](/developers/docs/nodes-and-clients/run-a-node/) -- [クライアント開発への貢献](/developers/docs/nodes-and-clients/#execution-clients) -- [コアデベロッパー実習プログラム](https://blog.ethereum.org/2021/09/06/core-dev-apprenticeship-second-cohort/) +- [EIPを提案する](/eips/#participate) +- [現在の提案について議論する](https://ethereum-magicians.org/) +- [R&Dの議論に参加する](https://ethresear.ch/) +- [Ethereum R&DのDiscordに参加する](https://discord.gg/mncqtgVSVw) +- [ノードを実行する](/developers/docs/nodes-and-clients/run-a-node/) +- [クライアント開発に貢献する](/developers/docs/nodes-and-clients/#execution-clients) +- [コアデベロッパー見習いプログラム](https://blog.ethereum.org/2021/09/06/core-dev-apprenticeship-second-cohort/) -## 参考文献 {#further-reading} +## 参考リンク {#further-reading} -イーサリアムのガバナンスは厳格には定義されていません。 さまざまなコミュニティ参加者が多様な視点を持っています。 下記にいくつかご紹介します。 +イーサリアムのガバナンスは厳格には定義されていません。 さまざまなコミュニティ参加者が多様な視点を持っています。 下記にこれらのいくつかをご紹介します。 -- [ブロックチェーンガバナンスのノート](https://vitalik.eth.limo/general/2017/12/17/voting.html) - _ヴィタリック・ブテリン_ +- [ブロックチェーンのガバナンスに関する注記](https://vitalik.eth.limo/general/2017/12/17/voting.html) - _Vitalik Buterin_ - [イーサリアムのガバナンスの仕組み](https://cryptotesters.com/blog/ethereum-governance) – _Cryptotesters_ -- [イーサリアムガバナンスの仕組み](https://medium.com/coinmonks/how-ethereum-governance-works-71856426b63a) – _Micah Zoltu_ -- [イーサリアムのコアデベロッパーについて](https://hudsonjameson.com/2020-06-22-what-is-an-ethereum-core-developer/) – _Hudson Jameson_ -- [ガバナンス・パート2: 金権政治は依然として悪](https://vitalik.eth.limo/general/2018/03/28/plutocracy.html) - _ヴィタリック・ブテリン_ -- [コイン投票ガバナンスを超えて](https://vitalik.eth.limo/general/2021/08/16/voting3.html) - _ヴィタリック・ブテリン_ +- [イーサリアムのガバナンスの仕組み](https://medium.com/coinmonks/how-ethereum-governance-works-71856426b63a) – _Micah Zoltu_ +- [イーサリアムのコアデベロッパーとは?](https://hudsonjameson.com/2020-06-22-what-is-an-ethereum-core-developer/) - _Hudson Jameson_ +- [ガバナンス、パート2: 金権政治はやはり良くない](https://vitalik.eth.limo/general/2018/03/28/plutocracy.html) - _Vitalik Buterin_ +- [コイン投票ガバナンスからの脱却](https://vitalik.eth.limo/general/2021/08/16/voting3.html) - _Vitalik Buterin_ +- [ブロックチェーンのガバナンスを理解する](https://web.archive.org/web/20250124192731/https://research.2077.xyz/understanding-blockchain-governance) - _2077 Research_ +- [イーサリアム・ガバメント](https://www.galaxy.com/insights/research/ethereum-governance/) - _Christine Kim_ diff --git a/public/content/translations/ja/guides/how-to-create-an-ethereum-account/index.md b/public/content/translations/ja/guides/how-to-create-an-ethereum-account/index.md index 9de010b1a7b..7a4203fbfa2 100644 --- a/public/content/translations/ja/guides/how-to-create-an-ethereum-account/index.md +++ b/public/content/translations/ja/guides/how-to-create-an-ethereum-account/index.md @@ -1,12 +1,12 @@ --- -title: イーサリアムアカウントの「開設」方法 -description: ウォレットを利用してイーサリアムのアカウントを開設する方法のステップバイステップガイド +title: "イーサリアムアカウントの「開設」方法" +description: "ウォレットを利用してイーサリアムのアカウントを開設する方法のステップバイステップガイド" lang: ja --- # イーサリアムアカウントの開設方法 -**イーサリアムアカウントは誰でも無料で作れます。** 仮想通貨ウォレットアプリをインストールするだけでOKです。 ウォレットがイーサリアムアカウントの作成と管理を行います。 ウォレットを使えば、トランザクションの送信、残高確認、イーサリアム上の他のアプリへの接続ができます。 +\*\*イーサリアムアカウントは誰でも無料で作成できます。\*\*暗号通貨ウォレットアプリをインストールするだけです。 ウォレットがイーサリアムアカウントの作成と管理を行います。 ウォレットを使えば、トランザクションの送信、残高確認、イーサリアム上の他のアプリへの接続ができます。 また、ウォレットがあれば、トークン取引所、ゲーム、[NFT](/glossary/#nft)マーケットプレイスに即座にログインできます。 イーサリアム上のアプリでは個別の登録は不要で、1つのアカウントですべてにアクセスできます。 @@ -14,7 +14,6 @@ lang: ja ウォレットはイーサリアムアカウントを管理するアプリです。 ウォレットには、モバイル、デスクトップ、ブラウザ拡張機能など、数十種類の異なる選択肢があります。 - ウォレットのリスト @@ -31,27 +30,27 @@ lang: ja ## ステップ 3: アプリを開いて、イーサリアムアカウントを開設する -新しいウォレットを初めて開くと、新しいアカウントを開設するか、既存のアカウントをインポートするかを選択するよう求められる場合があります。 新しいアカウントの開設をクリックします。 **このステップで、ウォレットソフトウェアがあなたのイーサリウムアカウントを作成します。** +新しいウォレットを初めて開くと、新しいアカウントを開設するか、既存のアカウントをインポートするかを選択するよう求められる場合があります。 新しいアカウントの開設をクリックします。 **このステップで、ウォレットソフトウェアがあなたのイーサリアムアカウントを生成します。** ## ステップ 4: リカバリーフレーズを保存する 一部のアプリでは、秘密の「リカバリーフレーズ」(「シードフレーズ」や「ニーモニック」とも呼ばれることがあります) を保存するよう求められることがあります。 このフレーズを安全に保管することは非常に重要です! このフレーズはイーサリウムアカウントを生成するために使用され、トランザクションを送信するためにも利用できます。 -**このフレーズを知っている人は、全ての資金を管理することができます。**絶対に他人と共有しないでください。 このフレーズには、ランダムに生成された12~24個の単語を含めるべきです(単語の並び順も重要です)。 +\*\*このフレーズを知っている人は、誰でもすべての資金を管理できてしまいます。\*\*絶対に誰とも共有しないでください。 このフレーズには、ランダムに生成された12~24個の単語を含めるべきです(単語の並び順も重要です)。 - ウォレットをインストールしましたか?その使い方を学びましょう。 + ウォレットはインストールしましたか?使い方を学びましょう。 ウォレットの使用方法 - + -他のガイドに興味がありますか? ぜひ、[ステップバイステップのガイド](/guides/)をご覧ください。 +他のガイドに興味がありますか? こちらもご覧ください: [ステップバイステップガイド](/guides/) ## よくある質問 @@ -61,11 +60,11 @@ lang: ja ### ビットコインをイーサリアムのアドレスに送金したり、Etherをビットコインのアドレスに送金したりできますか? -できません。 ビットコインとイーサリアムは、それぞれ異なるネットワーク (つまり、異なるブロックチェーン) に存在しており、それぞれ独自の台帳形式やアドレス形式を持っています。 この2つの異なるネットワークを橋渡しするためのさまざまな試みが行われてきましたが、現在最も活発なものは[ラップドビットコイン(WBTC)](https://www.bitcoin.com/get-started/what-is-wbtc/)です。 とはいえ、WBTCはカストディアル型 (特定の組織が重要な機能を管理している形) であり、情報提供のみが目的であるため、これは推奨される試みではありません。 +できません。 ビットコインとイーサは、2つの別々のネットワーク(すなわち異なるブロックチェーン)上に存在し、それぞれ独自の記帳方法とアドレス形式を持っています。 この2つの異なるネットワークをブリッジするためのさまざまな試みが行われてきましたが、現在最も活発なものは[ラップドビットコインまたはWBTC](https://www.bitcoin.com/get-started/what-is-wbtc/)です。 とはいえ、WBTCはカストディアル型 (特定の組織が重要な機能を管理している形) であり、情報提供のみが目的であるため、これは推奨される試みではありません。 ### ETHのアドレスを所有している場合、他のブロックチェーンでもそれと同じアドレスが使えますか? -イーサリアム上で構築されたソフトウェアを利用しているブロックチェーン(いわゆる、EVM互換ブロックチェーン)であれば同じ[アドレス](/glossary/#address)を使うことができます。 この [リスト](https://chainlist.org/) は、同じアドレスで使用できるブロックチェーンの一覧です。 ビットコインのような一部のブロックチェーンでは、全く別のネットワークの規定を実装しているため、異なるフォーマットのアドレスが必要になります。 スマートコントラクトウォレットをお持ちの場合、そのプロダクトの公式ウェブサイトを確認し、サポートしているブロックチェーンについて詳しく知るべきです。それらは一般的に、範囲は限定されるものの、より高いセキュリティが確保されています。 +イーサリアムと類似の基盤ソフトウェアを使用するすべてのブロックチェーン(「EVM互換」として知られています)で、同じ[アドレス](/glossary/#address)を使用できます。 この[リスト](https://chainlist.org/)には、同じアドレスで使用できるブロックチェーンが表示されています。 ビットコインのような一部のブロックチェーンでは、全く別のネットワークの規定を実装しているため、異なるフォーマットのアドレスが必要になります。 スマートコントラクトウォレットをお持ちの場合、そのプロダクトの公式ウェブサイトを確認し、サポートしているブロックチェーンについて詳しく知るべきです。それらは一般的に、範囲は限定されるものの、より高いセキュリティが確保されています。 ### 自分のウォレットを持つことは、取引所に資金を預けるよりも安全でしょうか?
MAX_EFFECTIVE_BALANCE
MCOPY
SELFDESTRUCT
BLOBBASEFEE
Sep-15-2022 06:42:42 AM +UTC
COINBASE
PUSH0
Sep-06-2022 11:34:47 AM +UTC
Jun-30-2022 10:54:04 AM +UTC
Dec-09-2021 07:55:23 PM +UTC
Oct-27-2021 10:56:23 AM +UTC
Aug-05-2021 12:33:42 PM +UTC
BASEFEE
0xEF
Apr-15-2021 10:07:03 AM +UTC
Dec-01-2020 12:00:35 PM +UTC
Oct-14-2020 09:22:52 AM +UTC
Jan-02-2020 08:30:49 AM +UTC
Dec-08-2019 12:25:09 AM +UTC
CHAINID
Feb-28-2019 07:52:04 PM +UTC
XTCODEHASH
Oct-16-2017 05:22:11 AM +UTC
REVERT
STATICCALL
Nov-22-2016 04:15:44 PM +UTC
EXP
Oct-18-2016 01:19:31 PM +UTC
Jul-20-2016 01:20:40 PM +UTC
Mar-14-2016 06:49:53 PM +UTC
DELEGATECALL
Sep-07-2015 09:33:09 PM +UTC
Jul-30-2015 03:26:13 PM +UTC