smacon.dev

About Sakanosita IC Labs | smacon.dev

Welcome to Sakanosita IC Labs! 🎉

Hey there! We’re Sakanosita IC Labs, founded in 2021 by our fearless leader, Moto Sakanosita. We’re a bunch of tech enthusiasts who love working on innovative projects and sharing our knowledge with the world. You can find our work at GitHub.

What we do 🚀

At Sakanosita IC Labs, we’re all about exploring the latest and greatest in technology. We work on a wide range of projects, from software development to hardware design, and everything in between. Our goal is to push the boundaries of what’s possible and to inspire others to do the same.

Get in touch 📬

Got questions or just want to chat? Feel free to reach out to us! You can find me on Twitter.

No title

はじめてのスマートコントラクト開発 | Web3 プログラミング入門

smacon.dev

はじめてのスマートコントラクト開発

Motoko ではじめるキャニスター開発 | ICP プログラミング学習

Sun, 14 May 2023 10:38:00 GMT

Cycle Wallet キャニスター図解: dfx identity (Principal ID), Ledger (Account ID)との関係

Sun, 14 May 2023 10:00:00 GMT

当記事では Internet Computer の dfx という開発ツールにおける秘密鍵やウォレットの取り扱いについて説明します。以下のような方に向いています

dfx を使ってキャニスターを本番メインネットにデプロイする
Cycle ウォレットとの取り扱い方を知りたい
Identity と Principal と Ledger と Wallet の関係を整理したい

図は Internet Computer の機能のうち、dfx の部分に絞って表しています。

dfx identity

dfx identity は, 1 組の Principal ID と秘密鍵に紐づきます。

上の図では 2 つの dfx identity を表しています。

aramaki
batou

dfx identity の秘密鍵

以下のコマンドで表示されます。

dfx identity export aramaki

Ledger Account

Ledger Account は ICP トークンの残高を管理します。 dfx identity ごとに 1 つの Ledger Account を持っています。

aramaki の Ledger Account は 2.0 ICP 保有
batou の Ledger Account は 1.5 ICP 保有

Canisters

キャニスターは Internet Computer 上のあらゆるアプリケーション（スマートコントラクト）の入れ物です。デプロイする時やキャニスターを走らせる時に Cycle が必要です。

batou は hello_frontend と hello_backend キャニスターをデプロイしています
hello_frontend は 2TCycle デポジットされています
hello_backend は 1TCycle デポジットされています

Cycle Wallet

dfx identity ごとにウォレットを作成したり削除したりできます。ウォレットごとに複数の Principal を contorller として追加でき、Controller となった Principal はそのウォレットの Cycle を利用したり、ウォレットを削除したりできます。

aramaki の Cycle Wallet は a で 3T Cycle 保有
batou の Cycle Wallet は b で 2T Cycle 保有
Cycle Wallet b の controller は aramaki と batou
- aramaki は Cycle Wallet b を利用することもできる

Cycle Wallet 自体もはキャニスターであり、最初に作る時に少量の ICP が必要です。

Cycle トークン

ICP トークンと交換することで入手できます。アプリケーションキャニスターにデポジットしたり、Cycle ウォレットにデポジットしたりして利用します。以下の場合には Cycle トークンが必要です。

キャニスターを作る時
キャニスターを走らせる時

Cycles Faucet

Faucet を利用すれば開発用の Cycles をもらうことができます。

上の図には書いていない説明

Principal ID は複数の Leger Account を保有できます、図は dfx identity に限定しているので 1 つの Ledger Account だけを持っています。
Ledger Account と ICP トークンの残高は特別な NNS サブネット上の Ledger Canister で管理されています。

Internet Computer 入門: メインネットにキャニスターをデプロイする手順

Sat, 13 May 2023 12:00:00 GMT

この記事はこんな人にオススメ

自分の作ったキャニスターをインターネット上で公開したい
Motoko エンジニア/プログラマになりたい
Internet Computer (DFINITY) に興味がある
ブロックチェーンや Dapps 開発に興味がある

当記事は、2023 年 5 月現在の DFINITY 公式のデプロイ手順をもとにした解説です。

Deploying to Internet Computer

初めての方はローカルでのデプロイから始めるといいですよ。

5 ステップではじめる Motoko プログラミング入門

前提

筆者の実行環境

M1 Mac (macOS 12.5.1)
dfx: 0.14.0
Node.js: V18.16.0

ICP / Cycle トークン

公式手順どおりに進めるためには以下の２つが必要になります。

A. ウォレットを作るための ICP トークン($1.5 相当)
B. 2 つのキャニスターをデプロイするための Cycle (6.3 TCycle 程度)

B については開発者向けの Faucet で Cycle をもらえるので活用してください。

Getting Started with Free Cycles

Faucet のしくみはたまに変わりますが、2023 年 5 月に筆者がもらった時は Discord で DM をやりとりしました。ただし DM で誰かに ICP を直接送ってくれと言われたら、それは 99%詐欺なので気をつけましょう。

本日のゴール

当記事のゴールはシンプルです。まず２つのコマンドを示します。

# ローカル開発環境へのデプロイ
dfx deploy

# Internet Computerメインネットへのデプロイ
dfx deploy --network ic

違いは --network ic オプションをつけるかどうかです。下のコマンドが成功すれば、メインネットにキャニスターをデプロイできます。

ソースコードを書いたりキャニスターをコンパイルするところまでは、ローカル開発でもメインネットでも同じです。

ただし、メインネットへのデプロイコマンドを実行するには Cycle ウォレットと Cycle トークンが必要となります。

Cycle トークン・ウォレットとは

この記事を読んでいる人の多くはすでに ICP トークンは知っていると思いますが、Internet Computer でキャニスターを走らせるためには Cycle トークンが必要です。

Ethereum や Solana などほかの多くのブロックチェーンとは異なり Internet Computer は dApps の利用者(ユーザー)ではなく、dApps の運営者(開発者)が Gas を負担します。

Internet Computer: Reverse Gas Model

ここでは以下の 2 つの用途で Cycle を使用します。

キャニスターを作成・デプロイする時の Cycle
デプロイ後のキャニスターを走らせるための Cycle

Internet Computer のウォレット自体もキャニスターとして作られます。 Cycle ウォレットを作る前にウォレットの概念をイメージで掴んでおきましょう。

dfx identity と ICP トークンと Cycle ウォレット

注意事項

ICP や Cycle のレートは変動しており、キャニスターの作成に必要な ICP や Cycle の量も変動します。

ICP や Cycle を節約したい気持ちもありますが、ギリギリの量で作業を進めてコマンド実行に失敗すると Cycle は戻ってこない場合もあります。

また今後の IC や dfx の仕様変更でコマンドの実行結果が同じにならない可能性もあります。

オススメなのは、開発専用のウォレットになくなってもいいと思える $10 程度の ICP を用意しておくことです。

こういったリスクを理解した上ですべて自己責任で作業を進めてください。

Deploying to Internet Computer

それでは実際に、公式のガイドに従って進めて行きましょう。以下のような流れとなっています。(2023 年 5 月現在)

Deploying to Internet Computer

Download and install
Verify the SDK is ready to use
Create a new project
Check the connection to the IC mainnet
Confirm your developer identity and ledger account
Creating a Cycles Wallet
Validate your cycles wallet
Register, build, and deploy the application
Test the dapp frontend

すでに dfx ツールまではインストール済みとして、「Create a new project」から始めます。

Create a new project

dfx new hello
cd hello

hello というプロジェクトを作ると、2 つのキャニスターのソースコードも自動で作られます。もちろんソースコードをあなたの好きに変えても構いません。

hello_frontend
hello_backend

IC mainnet にこの 2 つのキャニスターをデプロイすることになります。

Check the connection to the IC mainnet

IC mainnet との疎通を確認します。

hello % dfx ping ic
{
  "certified_height": 67799281  "ic_api_version": "0.18.0"  "impl_hash": "83128b3d340d81e601413dcebcbda3bdf0fd5dcb151f7cc0e43790cedd3e5f40"  "impl_version": "6d21535b301fee2ad3e8a0e8af2c3f9a3d022111"  "replica_health_status": "healthy"  "root_key": [48, 129, 130, 48, 29, 6, 13, 43, 6, 1, 4, 1, 130, 220, 124, 5, 3, 1, 2, 1, 6, 12, 43, 6, 1, 4, 1, 130, 220, 124, 5, 3, 2, 1, 3, 97, 0, 129, 76, 14, 110, 199, 31, 171, 88, 59, 8, 189, 129, 55, 60, 37, 92, 60, 55, 27, 46, 132, 134, 60, 152, 164, 241, 224, 139, 116, 35, 93, 20, 251, 93, 156, 12, 213, 70, 217, 104, 95, 145, 58, 12, 11, 44, 197, 52, 21, 131, 191, 75, 67, 146, 228, 103, 219, 150, 214, 91, 155, 180, 203, 113, 113, 18, 248, 71, 46, 13, 90, 77, 20, 80, 95, 253, 116, 132, 176, 18, 145, 9, 28, 95, 135, 185, 136, 131, 70, 63, 152, 9, 26, 11, 170, 174]
}

Confirm your developer identity and ledger account

Identity, Prncipal ID, Account ID を確認します。

dfx identity whoami
dfx identity get-principal
dfx ledger account-id

Identity は任意のものを使って進めてください。公式手順では dfx インストール直後のまま進めるので default になっています。

Principal ID
Account ID

の 2 つは後で使うのでメモするか、このコマンドをいつでも使えるように覚えておきましょう。

次は ICP トークンの残高を確認します。

dfx ledger --network ic balance

WARN: The default identity is not stored securely. Do not use it to control a lot of cycles/ICP. Create a new identity with `dfx identity new` and use it in mainnet-facing commands with the `--identity` flag

この時、WARN が表示されました。dfx identity を切り変える方法を勧めています。

もし、dfx identity を使い分けられる人はその方がより安全に運用できるのでそうしてください。

当記事ではなるべく公式手順どおりに進めたいので今後この WARN は無視します。（これ以降、実行結果に表示されるこの WARN を省略します）

先ほどのコマンドを実行します。

hello % dfx ledger --network ic balance
0.00000000 ICP

この時点ではまだ送金していないため 0.0 ICP の表示ですが、公式手順ではこのアカウントの ICP 残高が 10 ICP になっています。

hello % dfx ledger --network ic balance
10.00000000 ICP

これ以降の手順で ICP が必要になるので少量の ICP トークンを先ほどの Principal ID もしくは Account ID 宛に送金する必要があります。

以下のコマンドで表示されるあなたの Account ID (アドレス)に送りましょう。

dfx ledger --network ic account-id

ところで、公式手順の同じコマンドでは --network ic をつけていないことに気づきましたか？

じつは同じ秘密鍵を使えば Principal ID や Account ID はローカルでもメインネットでも同じ値になります。試しに以下のように比較してみてください。

dfx ledger account-id
dfx ledger account-id --network ic

送金はどこから送っても大丈夫です。（例：NNS, Plug, NFID、取引所からの引き出し）

ぼくは自分の Plug ウォレットから dfx ledger の Account ID へ 0.3 ICP を送金しました。送金後にもう一度 Ledger の残高を確認します。

hello % dfx ledger --network ic balance
0.30000000 ICP

この後の dfx 用のウォレットの作成には 0.7 TCycle ぐらい必要になるので、当記事ではこのうち 0.25 ICP($1.25 相当)を使います。

2023/5/12 現在のレート

1 ICP はおよそ $5
1 TCycle はおよそ $1.4

Creating a Cycles Wallet

2 つのコマンドを実行して Cycle ウォレットを作ります。ここでのポイントは

Cycle ウォレット自身もキャニスターである
キャニスターの作成は Cycle で支払うが、まだ Cycle ウォレットがないので最初だけは ICP で払う

 % dfx ledger --network ic create-canister nmcsh-pngle-oimvf-zeu3q-jbynm-qw3vr-44mgt-biuks-xjweo-q2j36-vae --amount .28
Transfer sent at block height 6106475
Using transfer at block height 6106475
Canister created with id: "gi5zp-fyaaa-aaaap-qbfwa-cai "

さきほど Account ID に送った 0.3 ICP の中から 0.25 ICP を使ってウォレットを作ります。この時に ICP が足りないとウォレットを作れません。

公式手順でも 0.25 ICP を使ってウォレットを作っていますが、法定通貨に対して ICP 高くなれば、もっと少ない ICP て良いはずです。目安は $1 ~ $1.2 ぐらいの ICP です。

 % dfx identity --network ic deploy-wallet "gi5zp-fyaaa-aaaap-qbfwa-cai "
Creating a wallet canister on the ic network.
The wallet canister on the "ic" network for user "default" is "gi5zp-fyaaa-aaaap-qbfwa-cai "

わたしのウォレットのキャニスター ID は gi5zp-fyaaa-aaaap-qbfwa-cai で作られました。

Validate your cycles wallet

hello % dfx identity --network ic get-wallet
gi5zp-fyaaa-aaaap-qbfwa-cai

hello % dfx wallet --network ic balance
0.806 TC (trillion cycles).

今日現在の 0.25 ICP を使って作ったウォレットには 0.806 TCycle 入っています。

ブラウザでウォレットを管理するためのインターフェースがあります。

https://<WALLET-CANISTER-ID>.icp0.io

2023 年 5 月現在筆者環境でこの機能は動作確認できませんでした。以前はこの機能を使えていましたが、おそらくウォレットの仕様のアップグレードの影響だと思います。

この機能が使えなくても先には進めるので、ここはいったん飛ばしましょう。（後日、確認できたら記事を更新します）

Deploy の前に Cycle を補充する

キャニスターのデプロイの前に Cycle を追加で取得する必要があります。この後で hello プロジェクトの 2 つのキャニスターを１発でデプロイするためには 6.3 TCycle 程度必要です。(2023 年 5 月現在)

公式ガイドの手順通りに簡単に進めるためにも Faucet を利用して 20 TCycle をもらうのがオススメです。

Getting Started with Free Cycles

補足：公式ガイドの手順とは異なりますがキャニスター作成時に Cycle の量を指定することで利用する Cycle の量を調整することができます。また、終わったらキャニスターを Stop & Delete すればキャニスターに Deposit した Cycle をウォレットに引き出すこともできます。

なんらかの事情で Faucet から貰えない場合や、多少の ICP を消費してでもたくさんの Cycle が必要な場合は、ICLight などの dapps で ICP を Cycle に交換したり、Cycle を dfx identity の wallet に送金するといったことできます。

hello % dfx wallet --network ic balance
8.139 TC (trillion cycles).

筆者のウォレットには 8.139 TCycle 入れました。

Register, build, and deploy the application

いよいよ当記事のゴールとして紹介したデプロイのコマンドが登場します。

まずは Node.js のライブラリをインストールします。はじめにプロジェクトを作るときにライブラリもインストール済みなので、ここではなにも起こらないかもしれません。

hello % npm install

up to date, audited 406 packages in 461ms

69 packages are looking for funding
  run `npm fund` for details

found 0 vulnerabilities

さていよいよデプロイコマンドです。

hello % dfx deploy --network ic
WARN: The batou identity is not stored securely. Do not use it to control a lot of cycles/ICP. Create a new identity with `dfx identity new` and use it in mainnet-facing commands with the `--identity` flag
Deploying all canisters.
Creating canisters...
Creating canister hello_backend...
hello_backend canister created on network ic with canister id: esbrt-3iaaa-aaaap-qbfza-cai
Creating canister hello_frontend...
hello_frontend canister created on network ic with canister id: evaxh-wqaaa-aaaap-qbfzq-cai
Building canisters...
Shrink WASM module size.
Building frontend...
WARN: Building canisters before generate for Motoko
WARN: .did file for canister 'hello_frontend' does not exist.
Shrink WASM module size.
Generating type declarations for canister hello_frontend:
  src/declarations/hello_frontend/hello_frontend.did.d.ts
  src/declarations/hello_frontend/hello_frontend.did.js
  src/declarations/hello_frontend/hello_frontend.did
Generating type declarations for canister hello_backend:
  src/declarations/hello_backend/hello_backend.did.d.ts
  src/declarations/hello_backend/hello_backend.did.js
  src/declarations/hello_backend/hello_backend.did

Installing canisters...
Installing code for canister hello_backend, with canister ID esbrt-3iaaa-aaaap-qbfza-cai
Installing code for canister hello_frontend, with canister ID evaxh-wqaaa-aaaap-qbfzq-cai
Uploading assets to asset canister...
Fetching properties for all assets in the canister.
Starting batch.
Staging contents of new and changed assets in batch 1:
  /favicon.ico 1/1 (15406 bytes) sha 4e8d31b50ffb59695389d94e393d299c5693405a12f6ccd08c31bcf9b58db2d4 (with 7 headers)
  /index.js.LICENSE.txt 1/1 (413 bytes) sha f2dcfd36875be0296e171d0a6b1161de82510a3e60f4d54cc1b4bec0829f8b33 (with 7 headers)
  /sample-asset.txt 1/1 (24 bytes) sha 2d523f5aaeb195da24dcff49b0d560a3d61b8af859cee78f4cff0428963929e6 (with 7 headers)
  /index.js.LICENSE.txt (gzip) 1/1 (273 bytes) sha db89b3ccdfe399f8ef3135c0b076326a0ae9e1c96409f79f8e686031537c572c (with 7 headers)
  /main.css (gzip) 1/1 (299 bytes) sha b4879e7ba34e68b2965d626e48d772ce615e4f6b78b69cc8f2f91127ed18b850 (with 7 headers)
  /logo2.svg 1/1 (15139 bytes) sha 037eb7ae523403daa588cf4f47a34c56a3f5de08a5a2dd2364839e45f14f4b8b (with 7 headers)
  /main.css 1/1 (537 bytes) sha 75ac0c5aea719bb2b887fffbde61867be5c3a9eceab3d75619763c28735891cb (with 7 headers)
  /index.html 1/1 (539 bytes) sha 053f9dc1283c64d114d43cbf03b0b0062afae08a04a5044ae58dbc68f4a1f93f (with 7 headers)
  /index.html (gzip) 1/1 (350 bytes) sha 16289744897bd78f5df24924dac6972c19e0bb56f5ddcf695de65656b942d769 (with 7 headers)
  /index.js (gzip) 1/1 (88324 bytes) sha 03dd42729ce7df78926af89d9da96020425bc2ec160328ae6106e23e1b398efd (with 7 headers)
  /index.js 1/1 (246603 bytes) sha 4224eb8e09f0b05e9077f0feb1f851d9594700d5bb08093e7bcd63f477833c4e (with 7 headers)
Committing batch.
Deployed canisters.
URLs:
  Frontend canister via browser
    hello_frontend: https://evaxh-wqaaa-aaaap-qbfzq-cai.icp0.io/
  Backend canister via Candid interface:
    hello_backend: https://a4gq6-oaaaa-aaaab-qaa4q-cai.raw.icp0.io/?id=esbrt-3iaaa-aaaap-qbfza-cai

デプロイできました！いくつか WARN がありますが、無事にデプロイされるとこのようなログが表示されます。

公式手順ではデプロイした Canister に Cycle を追加する手順を紹介していますが、これは実行しなくても良いでしょう。

# 実行不要!!!
dfx ledger --network ic top-up gastn-uqaaa-aaaae-aaafq-cai --amount 1.005

バックエンドキャニスターを dfx コマンドで実行して確認します。

hello % dfx canister --network ic call hello_backend greet '("everyone": text)'
("Hello, everyone!")

つづいてブラウザからフロントエンドに繋いでみましょう！

Test the dapp frontend

公式ガイドが dfx の仕様に対して古いため、公式手順とは少し異なります。

デプロイしたときのログに hello_frontend の URL が表示されているのでそのままブラウザでアクセスすれば確認できます。

https://<hello_frontend のキャニスター ID>.icp0.io/

hello_frontend キャニスターの ID を知りたいときは

dfx canister id --network ic hello_frontend

このようにブラウザで確認できれば成功です。

おまけ: キャニスターの Cycle を引き出してウォレットに入れる

このまま終わっても良いですが、デプロイしたキャニスターにはそれぞれ 3 TCycle ほどデポジットされています。キャニスターを削除すれば dfx identity の Cycle wallet に戻すことができます。

Cycle ウォレットの残高確認

% dfx wallet balance --network ic
1.939 TC (trillion cycles).

もともと 8.139 TC だったので 2 つのキャニスターのデプロイで 6.2 TC 消費したことになります。

キャニスターのステータス確認

dfx canister status hello_frontend --network ic
dfx canister status hello_backend --network ic

hello % dfx canister status hello_frontend --network ic
Canister status call result for hello_frontend.
Status: Running
Controllers: gi5zp-fyaaa-aaaap-qbfwa-cai nmcsh-pngle-oimvf-zeu3q-jbynm-qw3vr-44mgt-biuks-xjweo-q2j36-vae
Memory allocation: 0
Compute allocation: 0
Freezing threshold: 2_592_000
Memory Size: Nat(2209774)
Balance: 2_996_668_686_422 Cycles
Module hash: 0xe7866e1949e3688a78d8d29bd63e1c13cd6bfb8fbe29444fa606a20e0b1e33f0

キャニスターの Balance を見るとおよそ 3TCycle デポジットされていることを確認できます。

キャニスターの停止

Status=Running のままだとキャニスターを削除できないので、先に stop にします。

dfx canister stop hello_frontend --network ic
dfx canister stop hello_backend --network ic

キャニスターの削除

dfx canister delete hello_frontend --network ic
dfx canister delete hello_backend --network ic

Cycle ウォレットの残高確認

hello % dfx wallet balance --network ic
7.887 TC (trillion cycles).

全体で消費した量: 0.252 TC

デプロイ前: 8.139 TC
デプロイ後: 1.939 TC
削除後: 7.887 TC

デプロイ前後で消費した分: 6.2 TC

8.139（デプロイ前）- 1.939 (デプロイ後)

削除前後でウォレットに戻った分: 5.948 TC

1.939 (削除前) - 7.887（削除後）

おわり！

よかったらシェアしてください

5ステップではじめる Motoko プログラミング | DFINITY ICP 入門

Sat, 29 Apr 2023 20:30:00 GMT

この記事はこんな人におすすめです

Motoko エンジニア/プログラマを目指している(初心者)
Internet Computer に興味がある
ブロックチェーンや Dapps 開発に興味がある
将来 Web エンジニアになりたい

はじめに

当記事で紹介する５つのステップは、DFINITY の公式ページに簡潔にまとまっています。

Deploy your first ICP dapp in 5 minutes

Internet Computer は 2021 年 5 月にローンチしたサービスで、これまでの一般的な Web 開発をもっとシンプルに変えてくれます。

インターネットそのものを TCP/IP のレイヤーから見直して再設計しており、裏側ではブロックチェーンやゼロ知識証明、秘密分散といった暗号技術を組み合わせて使っています。

誰でもパソコンさえあれば簡単に始めることができるので、まずは実際にやってみましょう。

必要なスキル、前提知識

当記事を進めるためには、以下のスキルが必要です。

ターミナル等を使ってコマンドを入力できる（必須）
npm コマンドを実行できる（任意）

コマンドは、cd と ls が使えれば大丈夫です。

ステップ 5 でライブラリを使うために npm が登場しますが、必須ではありません。ブラウザ経由でスマートコントラクトを実行するために npm を使っています。 npm がわからなくてもステップ 4 までは進めらるので、スマートコントを実行することができます。

実行環境

本記事では以下の Mac 環境を使った開発を紹介しています。

macOS: 12.5.1 Monterey
dfx: 0.14.0
node: v16.9.1
npm: 7.21.1

ステップ 1: dfx(SDK)をインストールする

ターミナルソフトで以下のコマンドを実行します。

sh -ci "$(curl -fsSL https://sdk.dfinity.org/install.sh)"

これで SDK のインストールは完了です。 dfx コマンドを実行できるようになります。

$ dfx --version
dfx 0.14.0

ステップ 2: Hello World プロジェクトを作る

自分の好きな作業用ディレクトリを作って移動します。ぼくは dfinity というディレクトリを作っています。

mkdir dfinity
cd dfinity

dfinity ディレクトリの中に hello という名前の Hello World プロジェクトを作ります。

dfx new hello

少し時間がかかって以下のような画面が表示されます。

added 405 packages, and audited 406 packages in 35s

69 packages are looking for funding
  run `npm fund` for details

  Done.
Creating git repository...

===============================================================================
        Welcome to the internet computer developer community!
                        You're using dfx 0.14.0

            ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄                ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
          ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄          ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
        ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄      ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
       ▄▄▄▄▄▄▄▄▄▄▀▀▀▀▀▄▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄▄▀▀▀▀▀▀▄▄▄▄▄▄▄▄▄▄
      ▄▄▄▄▄▄▄▄▀         ▀▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▀         ▀▄▄▄▄▄▄▄▄▄
     ▄▄▄▄▄▄▄▄▀            ▀▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▀             ▄▄▄▄▄▄▄▄
     ▄▄▄▄▄▄▄▄               ▀▄▄▄▄▄▄▄▄▄▄▄▄▀                ▄▄▄▄▄▄▄
     ▄▄▄▄▄▄▄▄                ▄▄▄▄▄▄▄▄▄▄▄▄                 ▄▄▄▄▄▄▄
     ▄▄▄▄▄▄▄▄               ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄              ▄▄▄▄▄▄▄▄
      ▄▄▄▄▄▄▄▄           ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄          ▄▄▄▄▄▄▄▄▀
      ▀▄▄▄▄▄▄▄▄▄▄     ▄▄▄▄▄▄▄▄▄▄▄▄▀ ▀▄▄▄▄▄▄▄▄▄▄▄▄    ▄▄▄▄▄▄▄▄▄▄▄
       ▀▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▀     ▀▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▀
         ▀▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▀         ▀▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
           ▀▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▀▀             ▀▀▄▄▄▄▄▄▄▄▄▄▄▄▄▄▀
              ▀▀▀▀▀▀▀▀▀▀▀                    ▀▀▀▀▀▀▀▀▀▀▀



To learn more before you start coding, see the documentation available online:

- Quick Start: https://internetcomputer.org/docs/current/tutorials/deploy_sample_app
- SDK Developer Tools: https://internetcomputer.org/docs/current/developer-docs/setup/install/
- Motoko Language Guide: https://internetcomputer.org/docs/current/motoko/main/about-this-guide
- Motoko Quick Reference: https://internetcomputer.org/docs/current/motoko/main/language-manual
- Rust CDK Guide: https://internetcomputer.org/docs/current/developer-docs/backend/rust/

If you want to work on programs right away, try the following commands to get started:

    cd hello
    dfx help
    dfx new --help

===============================================================================

tree コマンドで hello ディレクトリにどんなファイルが作られたのか見てみましょう。

 % tree -L 1 hello
hello
├── README.md
├── dfx.json
├── node_modules
├── package-lock.json
├── package.json
├── src
└── webpack.config.js

ステップ 3: ローカル実行環境を起動する

hello ディレクトリに移動して、ローカル PC 上のテスト用 IC 環境を起動します。

cd hello
dfx start --background

以下のようなログが表示されます。

hello % dfx start --background
Running dfx start for version 0.14.0
Using the default definition for the 'local' shared network because /Users/sakanosita/.config/dfx/networks.json does not exist.
Dashboard: http://localhost:50362/_/dashboard

一番最後にダッシュボードの URL が表示されるので、ブラウザでアクセスすると以下のような画面をみることができます。

http://localhost:50362/_/dashboard (ポート番号は環境によって変わるかもしれません)

これであなたの PC 上にテスト用の Internet Computer が起動できました。 dfx ping コマンドを打つと、つながるかどうか疎通を確認できます。

hello % dfx ping
{
  "ic_api_version": "0.18.0"  "impl_hash": "8907d861e568171490efc74e7ae687d55aa5f9497a6a2c686d6d5df44556cbe1"  "impl_version": "0.8.0"  "replica_health_status": "healthy"  "root_key": [48, 129, 130, 48, 29, 6, 13, 43, 6, 1, 4, 1, 130, 220, 124, 5, 3, 1, 2, 1, 6, 12, 43, 6, 1, 4, 1, 130, 220, 124, 5, 3, 2, 1, 3, 97, 0, 141, 64, 198, 109, 225, 153, 11, 113, 230, 222, 56, 48, 71, 153, 112, 178, 173, 86, 211, 60, 12, 231, 13, 125, 156, 66, 122, 226, 136, 220, 145, 107, 67, 209, 92, 234, 13, 147, 150, 135, 133, 121, 210, 157, 252, 255, 145, 72, 5, 183, 206, 73, 251, 86, 146, 45, 184, 209, 49, 205, 249, 143, 71, 220, 150, 179, 252, 110, 159, 186, 61, 71, 62, 231, 247, 254, 69, 151, 122, 34, 197, 194, 95, 122, 178, 117, 71, 169, 142, 189, 94, 202, 77, 77, 151, 197]
}

上記のようにエラーではなく JSON フォーマットの謎の数字が返ってきたら成功です。

ステップ 4: ビルドしてデプロイする

以下のコマンドを実行してフロントエンド用のライブラリをインストールします。

npm install

npm を使って JavaScript のライブラリをインストールしています。

フロントエンドのプログラムは Chrome などのブラウザで実行することになるので、DFINITY の場合でも、そうじゃなくても同じ JavaScript を使います。

続いて、Hello World プログラムをビルドしてローカル実行環境にデプロイします。

dfx deploy

このコマンドの最後に出力されるログをメモしておきましょう。具体的には以下のように表示された URL にあとえブラウザからアクセスします。

Deployed canisters.
URLs:
  Frontend canister via browser
    hello_frontend: http://127.0.0.1:4943/?canisterId=bd3sg-teaaa-aaaaa-qaaba-cai
  Backend canister via Candid interface:
    hello_backend: http://127.0.0.1:4943/?canisterId=be2us-64aaa-aaaaa-qaabq-cai&id=bkyz2-fmaaa-aaaaa-qaaaq-cai

この dfx deploy コマンドでは、以下の 3 つのことをまとめてやってくれます。

ローカル実行環境にキャニスターを作る（ID を取得する）
Motoko で書いたソースコードをコンパイルして、WASM 実行プログラムを作る
WAS 実行プログラムをキャニスターにインストールする

キャニスターや WASM について今はわからなくても大丈夫です。この３つはそれぞれ以下のコマンドで個別に実行することができます。

dfx canister create
dfx build
dfx canister install

dfx deploy はこの３つをまとめて、しかも終わっていないところだけを実行してくれる便利なコマンドです。

ステップ 5: Hello World プログラムを実行する

以下のコマンドを実行すると、ローカル PC 上の Internet Computer で動くキャニスターを実行することができます。

dfx canister call hello_backend greet everyone

このコマンドの意味は以下のとおりです。

キャニスターの別名: hello_backend
実行する関数(命令): greet
関数に渡す値: everyone

$ dfx canister call hello_backend greet everyone
("Hello, everyone!")

解説

本来 Internet Computer 上でキャニスターを指定する場合はキャニスター ID を使います。しかし、dfx コマンドの機能として、キャニスター ID に名前をつけて使うことができます。キャニスターの名前は、dfx.json によってつけられており、キャニスター ID との紐付けは ./.dfx/local/canister_ids.json で確認できます。

今後は、作ったプログラムをブラウザで呼び出してみましょう。フロントエンドのプログラムを起動します

npm start

先ほどメモしておいた、dfx deploy の出力に含まれる URL にアクセスしてください。

http://127.0.0.1:4943/?canisterId=(キャニスターID)

名前をいれてクリックしてみましょう、先程ローカルの IC にデプロイしたキャニスターを実行して結果をブラウザで表示します。

今は、ローカル PC 上の実行環境にデプロイしたプログラム（キャニスター）を呼び出しています。

これから ICP トークンや Cycle トークンを使って、インターネット上の Internet Computer にキャニスターをデプロイすることで、世界中のどこからでも自分の作るキャニスターを呼び出せるようになります。

Internet Computer の世界へようこそ

公式のチュートリアルや Examples を日本語で解説しています。

Start Coding for DFINITY

Sat, 29 Apr 2023 18:38:00 GMT

INTERNET COMPUTER Developer Docs

https://internetcomputer.org/docs/current/home

Sample Code

https://internetcomputer.org/samples

Motoko SDK

https://internetcomputer.org/docs/current/motoko/main/about-this-guide

Rust SDK

https://internetcomputer.org/docs/current/developer-docs/backend/rust/

Best Practices for Canisters in Rust

Dev Forum

https://forum.dfinity.org/

NFID

https://nfid.one/

NFID Docs

Community Consideration

Community Conversations

In-site Pages

イーサリアム入門: オラクルのしくみ（Chainlink Data Feeds）

Sat, 27 Aug 2022 19:00:00 GMT

オラクルはスマートコントラクトがオフチェーンの情報を利用するときに使います。

通常の Web サービスでは、他のサービスに HTTP のリクエストを投げて外部の API を実行できます。しかしイーサリアムでは EVM 上のスマートコントラクトから直接 TCP/IP のリクエストを投げることはできません。

そのため、オフチェーンのデータを間接的に取得してスマートコントラクトから利用できるようにオラクルというしくみがあります。

代表的なオラクルの１つに Chainlink があります。このページでは Chainlink Data Feeds を使ってオラクルのしくみを見ていきましょう。

Architecture Overview (Chainlink Docs)

もし、Solidity における実装方法を知りたい場合はこちらをどうぞ。

Solidity 入門: オラクルを使う

構成要素の説明

Consumer

一般の開発者が作るスマートコントラクト
オフチェーンのデータを使うときは、同じチェーン上のスマートコントラクトである Proxy の関数を実行して、Aggregator が保持する state を参照できる

Proxy

Chainlink によって各チェーン上にデプロイされたスマートコントラクト
Proxy は Aggregator のコントラクトアドレスを保持しており、Aggregator を変更する場合でも Proxy のコントラクトアドレスが変わらないため、Consumer は継続してオラクルを利用できる
仮に Proxy の秘密鍵の保持者に悪意があれば、参照する Aggregator を変更できてしまうので Proxy の Owner を信頼しなければならない

Aggregator

Chainlink によって各チェーン上にデプロイされたスマートコントラクト
Consumer が利用したいオフチェーンの情報を保持し、一定間隔で更新する

Off Chain Node

Chainlink の P2P ネットワークを構成するクライアント
オフチェーンにあり、インターネット上の任意の API を実行できる
一定間隔で Aggregator の Write 関数を実行して、ブロックチェーンにデータを送る

OCR (Off Chain Reporting)

https://docs.chain.link/docs/off-chain-reporting/

従来は、各 Off Chain Node が個別に Aggregator にデータを送っていましたが、トランザクションが輻輳したり全体の Gas 代が高くなるというデメリットがありました。

それを改善するため OCR という新しいしくみにアップグレードしています。

P2P ノード間でリーダーを選出して、全体でレポートを作成、署名
全体で署名したレポートを代表するノードが Aggregator に提出
Aggregator は署名を確認し、全体の中央値を選ぶ
リーダーやレポートを提出するノードはラウンドごとに入れ替わる

実際の Aggregator の state を覗いてみよう

実際に Ethereum のメインネットで Proxy や Aggregator コントラクトの関数を実行してみましょう。 Read 関数なので Gas 代はかかりません。

各チェーンの Proxy のコントラクトアドレスは Chainlink の Documentation に載っています。

Ethereum Data Feeds

上のページには ETH / USD の Proxy コントラクトアドレスが載っています。

Etherscan で見てみましょう。

Proxy

https://etherscan.io/address/0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419

Contract Name: EACAggregatorProxy

[Contract] -> [Read Contract] -> [aggregator]をクリックすると Aggregator のアドレスがわかります。

Aggregator

https://etherscan.io/address/0x37bc7498f4ff12c19678ee8fe19d713b87f6a9e6#code

Contract Name: AccessControlledOffchainAggregator

[Contract] -> [Read Contract] -> [latestRoundData]をクリックすると以下のような複数の値を表示します。

  roundId|uint80 :  17400
  answer|int256 :  331512291099
  startedAt|uint256 :  1642312505
  updatedAt|uint256 :  1642312505
  answeredInRound|uint80 :  17400

ラウンド ID

現在のラウンド、つまり Chainlink が定義する集計間隔です。

answer

価格情報です。この Aggregator は ETH/USD の価格を持っています。桁数が大きいので 10 の 8 乗で割ってみましょう。

331512291099 / 10^8 = 3,315

3,315 が現在の Chainlink が提供する ETH/USD の価格情報です。

startedAt/updatedAt

これはプログラマにはおなじみの Unix タイムスタンプ形式の日時情報です。

1642312505 を ISO8601 フォーマットに変換すると以下のとおりです。

2022-01-16T06:31:12+00:00

実際のレポート提出トランザクションを見てみよう

Aggregator の Transactions を見ると、Off Chain Node から提出されたレポートの内容がわかります。

直前に送られた Transmit のトランザクション https://etherscan.io/tx/0xf56f41524a2fe7178b1d12bb0964221047438818e6d46f1b7eb0fc1aecb33192#eventlog

以下のようなログが見れます。

answer :
331512291099
transmitter :
0xdbfea8d5822141c13f92caa06eb94d0f3d67c243
observations :
331121345032
331136000000
331173629766
331175000000
331186000000
331200000000
331285910333
331302646333
（省略）

このラウンドで集められた価格情報の中央値が answer になっています。

transmitter のアドレスは、このコントラクトの Write 関数を実行したアカウント(EOA)です。

Chainlink の Off Chain Node がこのアカウントを使ってレポートを提出したようです。

このデータフィードでは、１つのレポートにまとめて送っているので OCR を使っているようです。

ほかのネットワーク上の Proxy/Aggregator や、ETH/USD 以外の Price Feeds など、いろいろ調べてみてください！

Solidity におけるオラクルの使い方を知りたい場合はこちらをどうぞ。

Solidity 入門: オラクルを使う

Solidity ではじめるスマートコントラクト入門 | Web3 プログラミング学習

Mon, 20 Jun 2022 10:00:00 GMT

Hardhat の使い方: 初心者向けの Solidity 開発入門

Sun, 19 Jun 2022 22:00:00 GMT

このページはこんな人におすすめ

Solidity を学習したい
テストネットやメインネットにスマートコントラクトを作りたい
Hardhat の使い方を知りたい

Hardhat は 2022 年現在、Solidity エンジニアの間でもっともよく使われている開発ツールの１つです。

Hardhat 以外によく使われるツールとしては Truffle があります。 Hardhat の方が新しくビルドやテストでより使いやすくなっています。

このページでは、Hardhat のチュートリアルを日本語で解説しています。チュートリアルの中からテストネットでの実行に必要な部分を抜粋しています。

https://hardhat.org/tutorial/

このページで実際に使ったソースコードはGitHubからダウンロードできます。

インストール

Hardhat の Document にしたがいインストールを進めます。

https://hardhat.org/tutorial/setting-up-the-environment.html

Hardhat を使うには、Nodejs のパッケージマネージャ npm を使います。

Hardhat はプロジェクトごとにインストールするので、この時点では PC のターミナルで npm コマンドを実行できれば環境構築は完了です。

Hardhat プロジェクトの作成

hardhat-tutorial という npm 用のプロジェクトを作り、hardhat をインストールします。

mkdir hardhat-tutorial
cd hardhat-tutorial
npm init --yes
npm install --save-dev hardhat

新しいプロジェクトに Hardhat をインストールできました。 hardhat コマンドを実行して、hardhat の設定ファイルを作ります。

npx hardhat

npx というコマンドは npm によってインストールしたコマンドを実行するためのコマンドです。 npm でインストールしたコマンドをそのまま入力しても見つけられないので npx を使います。

選択肢が表示されたら、Create an empty hardhat.config.jsを選びます。

? What do you want to do? …
  Create a sample project
❯ Create an empty hardhat.config.js
  Quit

プロジェクトディレクトリに Hardhat の設定ファイルhardhat.config.jsが作られます。

Create a sample projectを選択すれば、このあとの作業をもっと簡単にすすめることができます。

ここではプロジェクトの構成を理解するために、1 つ 1 つ自分で作っていきましょう。

プラグインの追加

ether.js や waffle といった Hardhat のプラグインを追加します。

npm install --save-dev @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai

スマートコントラクトの作成

コーディング

hardhat.config.js を以下のように編集します。

hardhat.config.js

require("@nomiclabs/hardhat-waffle");

/**
 * @type import('hardhat/config').HardhatUserConfig
 */
module.exports = {
  solidity: "0.7.3",
};

執筆時点での Hardhat のドキュメントのコードをそのまま使っています。 Solidity のバージョンが少し古いので、バージョン番号は適宜更新してください。

プロジェクトに contracts というディレクトリを作りましょう。 contracts ディレクトリの中に Token.sol というファイルを作り、下のコードを書きます。

contracts/Token.sol

// Solidity files have to start with this pragma.
// It will be used by the Solidity compiler to validate its version.
pragma solidity ^0.7.0;


// This is the main building block for smart contracts.
contract Token {
    // Some string type variables to identify the token.
    // The `public` modifier makes a variable readable from outside the contract.
    string public name = "My Hardhat Token";
    string public symbol = "MHT";

    // The fixed amount of tokens stored in an unsigned integer type variable.
    uint256 public totalSupply = 1000000;

    // An address type variable is used to store ethereum accounts.
    address public owner;

    // A mapping is a key/value map. Here we store each account balance.
    mapping(address => uint256) balances;

    /**
     * Contract initialization.
     *
     * The `constructor` is executed only once when the contract is created.
     */
    constructor() {
        // The totalSupply is assigned to transaction sender, which is the account
        // that is deploying the contract.
        balances[msg.sender] = totalSupply;
        owner = msg.sender;
    }

    /**
     * A function to transfer tokens.
     *
     * The `external` modifier makes a function *only* callable from outside
     * the contract.
     */
    function transfer(address to, uint256 amount) external {
        // Check if the transaction sender has enough tokens.
        // If `require`'s first argument evaluates to `false` then the
        // transaction will revert.
        require(balances[msg.sender] >= amount, "Not enough tokens");

        // Transfer the amount.
        balances[msg.sender] -= amount;
        balances[to] += amount;
    }

    /**
     * Read only function to retrieve the token balance of a given account.
     *
     * The `view` modifier indicates that it doesn't modify the contract's
     * state, which allows us to call it without executing a transaction.
     */
    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }
}

コンパイル

hardhat コマンドを実行します。

npx hardhat compile

出力
Downloading compiler 0.7.3
Compiling 1 file with 0.7.3
contracts/Token.sol: Warning: SPDX license identifier not provided in source file. Before publishing, consider adding a comment containing "SPDX-License-Identifier: <SPDX-License>" to each source file. Use "SPDX-License-Identifier: UNLICENSED" for non-open-source code. Please see https://spdx.org for more information.

Compilation finished successfully

テスト

プロジェクトの直下に test というディレクトリを作ります。 test ディレクトリの中に Token.js というファイルを作り、以下のコードを書きます。

test/Token.js

const { expect } = require("chai");

describe("Token contract", function () {
  it("Deployment should assign the total supply of tokens to the owner", async function () {
    const [owner] = await ethers.getSigners();

    const Token = await ethers.getContractFactory("Token");

    const hardhatToken = await Token.deploy();

    const ownerBalance = await hardhatToken.balanceOf(owner.address);
    expect(await hardhatToken.totalSupply()).to.equal(ownerBalance);
  });
});

コンパイル済みのスマートコントラクトに対して上のテストコードを使ってテストを実行します。

npx hardhat test

  Token contract
    ✓ Deployment should assign the total supply of tokens to the owner (565ms)


  1 passing (569ms)

テストネットへのデプロイ

Ethereum のテストネットにデプロイする方法はこちらをどうぞ

Hardhat の使い方: Ethereum のテストネットにデプロイしよう！

scripts/deploy.js

デプロイ用のスクリプトを用意します。

async function main() {
  const [deployer] = await ethers.getSigners();

  console.log("Deploying contracts with the account:", deployer.address);

  console.log("Account balance:", (await deployer.getBalance()).toString());

  const Token = await ethers.getContractFactory("Token");
  const token = await Token.deploy();

  console.log("Token address:", token.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

hardhat.config.js

hardhat.config.js を書き換えます。

require("@nomiclabs/hardhat-waffle");

const ROPSTEN_PRIVATE_KEY = process.env.ROPSTEN_PRIVATE_KEY;
const ROPSTEN_RPC_URL = process.env.ROPSTEN_RPC_URL;

module.exports = {
  solidity: "0.7.3",
  networks: {
    ropsten: {
      url: `${ROPSTEN_RPC_URL}`,
      accounts: [`${ROPSTEN_PRIVATE_KEY}`],
    },
  },
};

Ropsten にデプロイ

npx hardhat run scripts/deploy.js --network ropsten

Deploying contracts with the account: 0x470815ee5b366755284C9e85f0D636F1e046d013
Account balance: 1288845007486614009
Token address: 0xfa9D0729c104841668E0DDeb433Cbc6107AB59C1

このようなログが表示されたらテストネットへのデプロイが正常に実行されています。

Etherscan(Ropsten)でコントラクトアドレスやトランザクションを確認してみましょう。

https://ropsten.etherscan.io/address/0xfa9D0729c104841668E0DDeb433Cbc6107AB59C1

Metamask で確認

Hardhat のチュートリアルには載っていませんが、せっかくトークンを作ったので Metamask に登録してみましょう。

deploy.js を実行した際に出力されたToken addressを Metamask に登録します。

これで 1,000,000 MHT が見えるようになります。

これは Token.sol というサンプルコードであなたが作った’My Hardhat Token’です。

ほかのアドレスに送ることもできます。自由に試してください。

メインネット用の ETH と RPC を使えば同じやり方でメインネットにデプロイすることもできます。

Solidity / Hardhat の使い方: イーサリアムのテストネットにデプロイしよう！

Sun, 19 Jun 2022 11:00:00 GMT

このページはこんな人におすすめ

Solidity を学習したい
テストネットにスマートコントラクトを作りたい
Hardhat の使い方を知りたい

Hardhat 自体を使ったことがない場合は先に以下の記事をご覧ください。

Hardhat の使い方: 初心者向けの Solidity 開発入門

Ethereum のテストネットについて

Ethereum Networks

Gorli
Kovan
Kintsugi
Rinkeby
Ropsten

Ethereum には複数のテストネットが用意されています。

スマートコントラクトを開発するにあたっては、トークンや RPC エンドポイントを入手できるものであればどのネットワークを使っても構いません。

NFT を使った開発が目的であれば、Opensea が対応している Rinkeby がオススメです。

事前準備

テストネットにデプロイするために以下のものを準備します。

EOA（Externally Owned Account）の秘密鍵（Metamask ウォレットで使う秘密鍵)
テストネットの ETH トークン
テストネットの RPC エンドポイントの URL

１つずつ解説していきます。

EOA の秘密鍵

Ethereum のテストネットではスマートコントラクトをデプロイするためのアカウントとして EOA を使います。

EOA（Externally Owned Account）とはユーザーが使うアカウントのことで、Metamask で作るウォレット用のアカウントです。

Metamask でアカウントを作って Private Key をエクスポートすれば取得できます。

念のため、本番で使っているアカウントと分けることをおすすめします。

テストネットの ETH トークン

0.1ETH ぐらいあればデプロイには足りると思います。

テストネット用のトークンは、テストネットのノードを運営している団体が無料で配布したりしています。

以下のように Google 検索してみてください。

「Rinkeby Faucet」「Ropsten Faucet」

Faucet は蛇口という意味ですが、ブロックチェーンの開発においてテストネット用のトークンをもらうためのキーワードです。 Ethereum 以外でも Faucet で検索すればテストネット用のトークンを入手することができます。

Faucet では自分のアドレスを入力するだけで送られてくるものもあれば、SNS でシェアした URL を入力するともらえる場合などもあります。

Faucet でパスワードやシードフレーズを聞かれることはありません。もし聞かれたら偽物の詐欺サイトです。

RPC エンドポイントの URL

ブロックチェーンのネットワークにアクセスするためのエンドポイントです。

エンドポイントを使うということはブロックチェーンのノードにアクセスするということです。

Ethereum では PC やサーバを使って自分でノードを建てることができますが、ノードプロバイダーと呼ばれるを有名なサービスがいくつかあり、メインネットやテストネットのノードを無料で借りることができます。

INFURA
Alchemy
QuickNode

じつは Metamask で使われている RPC エンドポイントは INFURA というノードプロバイダーの RPC サーバです。

Metamask の Network の設定を開けば設定内容が見れるのでそれを使っても構いません。

筆者のおすすめは Alchemy です。ユーザー登録すれば、RPC サーバの URL を取得できて、ある程度まで無料プランで利用できます。

環境変数の設定

以下のような環境変数を設定します。

Ropsten の場合
- ROPSTEN_PRIVATE_KEY
- ROPSTEN_RPC_URL
Rinkeby の場合
- RINKEBY_PRIVATE_KEY
- RINKEBY_RPC_URL

env.txt

秘密鍵や API Key などのクレデンシャルは Git に commit しないようにする必要があります。

そこで環境変数の中身は、env.txt というファイルに書いて Git プロジェクトの外に置いたり、.gitignore を使って Git に commit しないようにしましょう。

export ROPSTEN_PRIVATE_KEY="<EOA の秘密鍵>"
export ROPSTEN_RPC_URL="https://ropsten.infura.io/v3/xxxxxxxx"

export RINKEBY_PRIVATE_KEY="<EOA の秘密鍵>"
export RINKEBY_RPC_URL="xhttps://eth-rinkeby.alchemyapi.io/v2/xxxxx"

ターミナルで以下のコマンドを実行すれば、環境変数の値を読み込んだ状態になります。

source env.txt

hardhat.config.js

hatdhat.config.js を以下のように編集します。

require("@nomiclabs/hardhat-waffle");

const ROPSTEN_PRIVATE_KEY = process.env.ROPSTEN_PRIVATE_KEY;
const ROPSTEN_RPC_URL = process.env.ROPSTEN_RPC_URL;

const RINKEBY_PRIVATE_KEY = process.env.RINKEBY_PRIVATE_KEY;
const RINKEBY_RPC_URL = process.env.RINKEBY_RPC_URL;

module.exports = {
  solidity: "0.x.x",
  networks: {
    ropsten: {
      url: `${ROPSTEN_RPC_URL}`,
      accounts: [`${ROPSTEN_PRIVATE_KEY}`],
    },
    rinkeby: {
      url: `${RINKEBY_RPC_URL}`,
      accounts: [`${RINKEBY_PRIVATE_KEY}`],
    },
  },
};

デプロイ

環境変数を設定したターミナルウィンドウで以下のコマンドを実行します。

# 環境変数を読み込む
source env.txt

# Ropsten にデプロイ
npx hardhat run scripts/deploy.js --network ropsten

# Rinkeby にデプロイ
npx hardhat run scripts/deploy.js --network rinkeby

デプロイするにはscripts/deploy.jsといったデプロイ用のスクリプトを用意する必要があります。

デプロイスクリプトの内容はスマートコントラクトによって変わります。

具体的なスクリプトが見たい場合はこれらのページをご覧ください。

W3C Security Standards and Drafts

Sat, 18 Jun 2022 15:00:00 GMT

W3C (World Wide Web Consortium)

All Security Standards and Drafts

DID

Web Authn

Verifiable Credentials

Verifiable Credentials Data Model v1.1

Organizations

The Graph 入門: はじめてのサブグラフ – Subgraph の自動生成

Tue, 24 May 2022 22:00:00 GMT

このページで作成したサブグラフのソースコードは GitHub からダウンロードできます。

サブグラフをデプロイして Subgraph Studio でクエリを実行することは無料で誰でもできます。

なるべく簡単な方法を紹介しています。 GraphQL は知らなくてもこのページで作ったサブグラフを試すことはできます。（サンプルクエリつき）

サブグラフを作成するときは、デプロイ済みのスマートコントラクトからコードを自動生成することができます。

非常にシンプルなスマートコントラクトから自動生成されるコードを使って簡単なサブグラフを作ってみましょう。

必要なもの

npm
Metamask とアカウント
Event スマートコントラクト

Metamask は Subgraph Studio を使うときに使いますが、ETH は不要(のはず)です。

Event スマートコントラクトは以下のページで作った非常にシンプルなスマートコントラクトです。もし、サブグラフだけ作りたいときは、筆者の作ったスマートコントラクトを使って進められます。

Solidity 入門: 定義したイベントを発行してブロックチェーンに記録

サブグラフを自動生成するためにスマートコントラクトが以下の条件を満たす必要があります。 Event スマートコントラクトはこの条件を満たしています。

Etherscan でコードを Verify していること
スマートコントラクトが events を発行していること

graph-cli のインストール

以下のコマンドを実行して、システムに graph-cli をインストールします。

npm install -g @graphprotocol/graph-cli

正しくインストールできれば、以下のように graph コマンドを実行できるようになります。

 % graph version
0.26.0

graph init

プロジェクト用のディレクトリを作り以下のコマンドを実行します。

graph init

いくつかの質問があるので答えます。

Protocol: ethereum
Product for which to initialize: subgraph-studio
Subgraph slug: event001
Directory to create the subgraph in: event001
Ethereum network: rinkeby
Contract address: 0xc5BeE3DDcD7F58380Aa0CA3D01dA63a34a9C3c09

このコントラクトアドレスは筆者が Rinkeby にデプロイしたコントラクトです。 https://rinkeby.etherscan.io/address/0xc5BeE3DDcD7F58380Aa0CA3D01dA63a34a9C3c09

 % graph init
✔ Protocol · ethereum
✔ Product for which to initialize · subgraph-studio
✔ Subgraph slug · event001
✔ Directory to create the subgraph in · event001
✔ Ethereum network · rinkeby
✔ Contract address · 0xc5BeE3DDcD7F58380Aa0CA3D01dA63a34a9C3c09
✔ Fetching ABI from Etherscan
✔ Contract Name · Event
  Generate subgraph
  Write subgraph to directory
✔ Create subgraph scaffold
✔ Initialize subgraph repository
✔ Install dependencies with yarn
✔ Generate ABI and schema types with yarn codegen

Subgraph event001 created in event001

Next steps:

  1. Run `graph auth` to authenticate with your deploy key.

  2. Type `cd event001` to enter the subgraph.

  3. Run `yarn deploy` to deploy the subgraph.

Make sure to visit the documentation on https://thegraph.com/docs/ for further information.

graph init を実行したディレクトリに event001 というディレクトリができて、その中にいろんなファイルが作られます。

ブロック番号の指定

このまま 1 行も変えずにデプロイすることもできますが、時間短縮のために 1 箇所だけ変えましょう。

どのブロックからデータの取得を開始するかを指定します。

subgraph.yaml

dataSources -> source -> startBlock

startBlock: 10028560

10028560 は Event コントラクトをデプロイしたときの Rinkeby のブロック番号です。

これを指定しないとコントラクトをデプロイする前のログまで分析してしまうので無駄に時間がかかります。

追加後の subgraph.yaml は以下のようになります。

subgraph.yaml

specVersion: 0.0.2
schema:
  file: ./schema.graphql
dataSources:
  - kind: ethereum
    name: Event
    network: rinkeby
    source:
      address: "0xc5BeE3DDcD7F58380Aa0CA3D01dA63a34a9C3c09"
      abi: Event
      startBlock: 10028560
    mapping:
      kind: ethereum/events
      apiVersion: 0.0.5
      language: wasm/assemblyscript
      entities:
        - AnotherLog
        - Log
      abis:
        - name: Event
          file: ./abis/Event.json
      eventHandlers:
        - event: AnotherLog()
          handler: handleAnotherLog
        - event: Log(indexed address,string)
          handler: handleLog
      file: ./src/mapping.ts

コードの自動生成＆ビルド

ここから先の作業はサブディレクトリで行います。（subgraph.yaml があるディレクトリ）

cd event001

コードを自動生成します。

graph codegen

% graph codegen
Skip migration: Bump mapping apiVersion from 0.0.1 to 0.0.2
Skip migration: Bump mapping apiVersion from 0.0.2 to 0.0.3
Skip migration: Bump mapping apiVersion from 0.0.3 to 0.0.4
Skip migration: Bump mapping apiVersion from 0.0.4 to 0.0.5
Skip migration: Bump mapping specVersion from 0.0.1 to 0.0.2
✔ Apply migrations
✔ Load subgraph from subgraph.yaml
Load contract ABI from abis/Event.json
✔ Load contract ABIs
Generate types for contract ABI: Event (abis/Event.json)
Write types to generated/Event/Event.ts
✔ Generate types for contract ABIs
✔ Generate types for data source templates
✔ Load data source template ABIs
✔ Generate types for data source template ABIs
✔ Load GraphQL schema from schema.graphql
Write types to generated/schema.ts
✔ Generate types for GraphQL schema

Types generated successfully

以下のコマンドを実行してサブグラフをビルドします。

graph build

% graph build
Skip migration: Bump mapping apiVersion from 0.0.1 to 0.0.2
Skip migration: Bump mapping apiVersion from 0.0.2 to 0.0.3
Skip migration: Bump mapping apiVersion from 0.0.3 to 0.0.4
Skip migration: Bump mapping apiVersion from 0.0.4 to 0.0.5
Skip migration: Bump mapping specVersion from 0.0.1 to 0.0.2
✔ Apply migrations
✔ Load subgraph from subgraph.yaml
Compile data source: Event => build/Event/Event.wasm
✔ Compile subgraph
Copy schema file build/schema.graphql
Write subgraph file build/Event/abis/Event.json
Write subgraph manifest build/subgraph.yaml
✔ Write compiled subgraph to build/

Build completed: /Users/sakanosita/ghq/github.com/smacon-dev/subgraphs/event001/build/subgraph.yaml

Subgraph のデプロイ

Subgraph Studio で Subgraph 作成

Subgraph Studio で Subgraph を作って、Deploy Key を用意します。 https://thegraph.com/studio/subgraph/

[Create a Subgraph]をクリックします。

[Ethereum Rinkeby]を選択
[任意の Subgraph 名]を入力

これでデプロイの準備ができました。

ローカルの graph コマンドの認証

以下のコマンドでローカルの graph コマンドを認証します


graph auth --studio <Deploy Key>

デプロイ

以下のコマンドを実行するとデプロイします。

graph deploy --studio event001

Version Label を効かれるのでv0.0.1を入力します。

event001 % graph deploy --studio event001
✔ Version Label (e.g. v0.0.1) · v0.0.1
Skip migration: Bump mapping apiVersion from 0.0.1 to 0.0.2
Skip migration: Bump mapping apiVersion from 0.0.2 to 0.0.3
Skip migration: Bump mapping apiVersion from 0.0.3 to 0.0.4
Skip migration: Bump mapping apiVersion from 0.0.4 to 0.0.5
Skip migration: Bump mapping specVersion from 0.0.1 to 0.0.2
✔ Apply migrations
✔ Load subgraph from subgraph.yaml
Compile data source: Event => build/Event/Event.wasm
✔ Compile subgraph
Copy schema file build/schema.graphql
Write subgraph file build/Event/abis/Event.json
Write subgraph manifest build/subgraph.yaml
✔ Write compiled subgraph to build/
Add file to IPFS build/schema.graphql
.. QmfDwzvSmUKGNFcdzW1HztSZ9nWRBchUwDMxjhzsuooYeT
Add file to IPFS build/Event/abis/Event.json
.. QmUWzzjttfyk8JDNTHHq46ergQphaVBjnc3VKCVPAYV33q
Add file to IPFS build/Event/Event.wasm
.. QmcfLjHPhH14RtGuaLnUnDrEFsBU4bW9pWBSYb6jiDt8Gs
✔ Upload subgraph to IPFS

Build completed: QmWd2aK1DWtCNNjGSULXuZavu1JAkFZreykYFmZ2aDiPDc

Deployed to https://thegraph.com/studio/subgraph/event001

Subgraph endpoints:
Queries (HTTP): https://api.studio.thegraph.com/query/610/event001/v0.0.1
Subscriptions (WS): https://api.studio.thegraph.com/query/610/event001/v0.0.1

これでサブグラフをデプロイできました。

クエリ実行

デプロイしてしばらくするとサブグラフのステータスが Synced になりクエリを実行できる状態になります。

Synced になったら、Playground でクエリを実行してみましょう。

GraphQL を知らなくてもデフォルトで入力されているクエリをそのまま実行すれば結果が返ってきます。

サンプルクエリ

{
  exampleEntities(first: 5) {
    id
    count
  }
}

実行結果

{
  "data": {
    "exampleEntities": [
      {
        "count": "3",
        "id": "0x1da392e33b2c00aeee46b9538a364751c8d8e00e"
      },
      {
        "count": "2",
        "id": "0x470815ee5b366755284c9e85f0d636f1e046d013"
      }
    ]
  }
}

この結果は、Event というスマートコントラクトの test()という関数を実行したアドレスと実行した回数を表しています。

Web3 プログラミング入門: 初心者向け Solidity 学習4選

Sun, 22 May 2022 10:00:00 GMT

この記事はこんな人におすすめです。

スマートコントラクト開発を始める人
Solidity の本を買ったけど、次に何をしたら良いかわからない人
開発環境の構築でつまずいた人
Web3/Dapps 開発に興味がある人

この記事で紹介するサイトやツールの一覧

CryptoZombies (クリプトゾンビ)
Solidity by Example
- Remix
- Hardhat
イーサリアム navi
Ethernaut

プログラミング初心者が挫折しないために

プログラミングを始めたばかりの人は、プログラムを実行する環境の問題が原因で挫折してしまう人がたくさんいます。

たとえば、サンプルコードをそのままコピーして動かない場合は、ほとんど環境側に問題があります。なぜなら、サンプルコード自体は本来間違っていないからです。

実行環境の問題を解決するためには、プログラミングの文法以外に多くの前提知識が必要になることがあります。

せっかくプログラミング言語を覚えたいのに、プログラミングとは関係ない部分で時間とやる気を浪費して挫折してしまいます。

もし、環境構築が不要なら覚えることはプログラミングだけに集中できます。

そこ最初におすすめするのは定番の CryptoZombies です。

CryptoZombies

https://cryptozombies.io/

ゲーム感覚で１つずつ課題をクリアしながら Solidity を学んでいきます。

CryptoZombies の良いところ

日本語に対応している
ゲーム感覚で面白い
プログラムをブラウザ上で実行できる
多くの Solidity エンジニアがここから入っている

CryptoZombies のイマイチなところ

内容が更新されておらず Solidity のバージョンが古い

ブラウザさえあれば、ほかに何も必要ないので初心者でもすぐに始められます。日本語に対応しているのも良いですね！

しかし、CrypboZombies は体系的に学習を進めていくので、自分に必要ないことも学習しなければなりません。ボリュームが多い上に、自分に必要かどうかもわからないことを理解しなければ先に進めなかったりするので段々とモチベーションが下がります。

プログラミング学習においては、必ずしも体系的な学習がベストではないとぼくは考えます。簡単なプログラムを実行できるようになったら、なるべく実際にプログラムを動かしてみることをおすすめします。

そこで、次はいろんなコードサンプルから自分が気になるものを選んで実際に動かしてみましょう。

Solidity by Example

https://solidity-by-example.org/

Solidty をある程度学んだら、次にやるべきことは自分でコンパイルして動かしてみることです。

サンプルコードをコンパイルして、テストネットにデプロイしたり実行してみましょう。 Solidity by Example のうち、いつくかのサンプルコードを当サイトでも解説しています。

実際にビルドしたり、デプロイすればいろんなエラーに必ずぶつかります。しかし、プログラマにとって大事なことは言語の文法を知っていることではなく問題を解決する力です。

エラーがおきたとき、はじめのうちは原因を切り分けるのが大変です。サンプルコードならコード自体はだいたい正しいと言えるのでエラーの原因を絞り込むことができます。

テスト環境にデプロイするための 2 つの方法をご紹介します。そのときの自分に合っている方法を試してください。

Remix
Hardhat

Remix

https://remix.ethereum.org/

Remix はブラウザでコードを編集したり、Metamask ウォレットを使ってテストネットやメインネットにスマートコントラクトをデプロイできる無料サービスです。

Remix の使い方はこちらのページにまとめてあります。（画像多め）

Remix の使い方: Metamask でスマートコントラクトをデプロイ

Hardhat

https://hardhat.org/

Hardhat はローカル PC に仮想のスマートコントラクト実行環境を作ることができます。 2022 年現在、Solidity エンジニアがメインネットのデプロイにもよく使っています。

Hardhat を使ったデプロイ方法はこちら

Hardhat の使い方: 初心者向けのスマートコントラクト開発 Hardhat の使い方: Ethereum のテストネットにデプロイしよう！

自分の気になるサンプルコードを選んだり、エラーにぶつかったり、その解決方法を検索したりして進めてください。そうした小さな成功体験の積み重ねこそがかならずエンジニアとして成長に繋がります。

進んでいくうちに、自分だけで解決できない問題にぶつかるかもしれません。

そんなときは相談できる相手や、一緒に学習を進める仲間が欲しくなります。

つぎに紹介するイーサリアム navi はそんな人たちが集まるコミュニティです。

イーサリアム navi

https://ethereumnavi.com/

でりおてんちょーさんというエンジニア(NFT リサーチャー)が、運営されているサイトと無料の Discord コミュニティです。

でりおてんちょーさん自身が Solidity を学習しながら、みんなで一緒に成長しているぬくもりのあるコミュニティです笑

不定期で勉強会なども開催しているので、Discord に参加したり、Twitter をフォローしましょう。

日本の Solidity エンジニアはまだ数が少ないので、結構すごい人が勉強会に参加することもあるかも？

Ethernaut

https://ethernaut.openzeppelin.com/

Ethernaut は中上級者向けで、Chrome の Developer Tools の Console を使って、ゲーム感覚で Solidity を学ぶことができます。

Ethernaut の良いところ

テストネットのスマートコントラクトを実際に操作している
ゲーム感覚で学ぶことができる
プログラムの脆弱性の問題を理解できる

はじめに Metamask を使って Ethereum のテストネットに繋ぎます。

ブロックチェーンのテストネットにあるスマートコントラクトを実際に操作しながら進むので、ブロックチェーンを実際に使いながら理解できます。

スマートコントラクトの実行には Web3.js を使うので JavaScript の知識が多少必要になるかもしれません。

このサイトがほかと違うのは、問題の内容がスマートコントラクトの脆弱性、つまりバグを見つけるようになっているからです。

ぼく自身も、まだ少ししかやっておりませんが、プログラムのバグを見つけるという課題は、高度なプログラミング知識を求められるので、この課題をマスターしたら、開発における高度かつ実践的なスキルが身につきます。

EVM と WASM の違い | Web3 プログラミング, スマートコントラクト入門

Fri, 20 May 2022 15:00:00 GMT

この記事はこんな人にぴったり

EVM と WASM の特徴を理解したい
スマートコントラクト開発を始めたい
Web3 エンジニアになりたい

EVM と WASM の特徴

EVM (Ethereum Virtual Machine) と WASM (Web Assembly) はどちらもブロックチェーン上のスマートコントラクトを実行するための環境として使われています。

iPhone と Android に喩えるとわかりやすいかもしれません。

どちらで Dapps を開発することもできますが、それぞれのメリット・デメリットを考慮する必要があります。

代表的なブロックチェーン

EVM

WASM

開発言語

EVM のスマートコントラクトは Solidity を使って開発します。

WASM はいろんなプログラミング言語を WASM にコンパイルすることができますが、代表的なものは Rust と C (C++) です。

誕生背景

EVM は名前の通り、Ethereum 上でスマートコントラクトを動かすために開発されました。

EVM と Solidity は Ethereum とともに開発されてきたので、ブロックチェーンやスマートコントラクトを実装するために最適化されています。

一方で、WASM はもともとブラウザで実行するプログラムのフォーマットとして設計されています。

互換性と拡張性

EVM は互換性が高いので、Ethereum 用に開発した Solidity のスマートコントラクトやライブラリ、開発ツールをほとんどそのまま他のチェーンでも使うことができます。

互換性が高いことはメリットにもなりますが、それが制約になってしまうというデメリットにつながります。

たとえばウォレットの機能やアカウントの権限を拡張したいと思っても EVM の仕様以外のことはできません。

そういった EVM のチェーンにできないことをできるようにしたチェーンの多くが採用しているのが WASM です。

ゼロ知識証明を学ぼう | Web3 プログラミング, スマートコントラクト入門

Fri, 20 May 2022 12:00:00 GMT

ゼロ知識証明とは？

ゼロ知識証明は、これまでのシステムやサービスにおいてできなかったことをできるようにしてくれるしくみです。

準同型暗号や秘密計算といった数学の理論をもとにしており、秘密にしたい情報を公開せずに計算したり、証明したりするときに使います。

ゼロ知識証明自体は、ブロックチェーンに限らずどんな分野でも使うことができますが、ブロックチェーンの課題を解決するために Web3 界隈で活発に研究が進められてきました。

開発で使うためには数学やプログラミング、あるいはブロックチェーンの知識が必要ですが、ゼロ知識証明の概念を理解したり使うだけなら、誰にでもできます。

YouTube

YouTube のこの動画では、子供でもわかるようにゼロ知識証明を説明しています。

日本語字幕はまだありませんが、YouTube の自動翻訳を使えば理解の助けになると思います。

Computer Scientist Explains One Concept in 5 Levels of Difficulty | WIRED

ゼロ知識証明を使った事例

ゼロ知識証明は、ブロックチェーンだけでなく既存の IT システムでも活用することができます。

台湾では、コロナ対策のためにゼロ知識証明や QR コードを使ってプライバシーを保護しながら個人情報を共有するシステムを開発して、社会に役立ったという事例があります。

ブロックチェーン的発想で社会を救う【オードリー・タン氏】

Zero-Knowledge University (zku.ONE)

ZKU (Zero-Knowledge University) ではオンラインでゼロ知識証明を体系的に学ぶことができます。

筆者は受講していないので詳細まで把握していませんが、2022 年時点でゼロ知識証明を学びたい人にとっては、ZKU がもっとも優れた環境の 1 つではないかと思います。

https://zku.one/

Ethereum L2 におけるゼロ知識証明

Ethereum のエコシステムにはスケーリングの課題があります。イーサリアムが世界中で使われるようになるとたくさんの処理をさばかなければなりません。そのために Rollup という手法が採用されました。

Rollup とはレイヤー 2 というブロックチェーンを作りその上で行われる取引を集約してレイヤー 1 である Ethereum にまとめて記録する方法です。

Rollup は大きく分けて Optimistic Rollup と ZK Rollup の 2 つの手法あります。 ZK Rollup の ZK はゼロ知識証明の Zero Knowledge です。

SNARK と STARK

ZK Rollup で使うゼロ知識証明には SNARK と STARK の 2 つのタイプがあります。

Zero-Knowledge Proofs: STARKs vs SNARKs

zk-SNARKs and zk-STARKs Explained

zkSNARKs vs zkSTARKs: a primer

SNARK と STARK にはそれぞれメリットがありますが、STARK のほうが SNARK よりあとに考案されており、SNARK のいくつかの弱点を補っています。

	SNARK	STARK
信頼すべき機関	必要	不要
量子コンピュータ耐性	なし	あり

それなら、SNARK より STARK のほうがいいのかと言えば、必ずしもそうとは言えません。 SNARK を使った ZkSync なら Solidity の資産を活かすことができます。

SNARK を使ったプロトコル

ZkSync
Loopring
Polygon Hermez

STARK を使ったプロトコル

Starkware
Polygon Miden

Rust ではじめるスマートコントラクト入門 | Web3 プログラミング学習

Thu, 19 May 2022 20:38:00 GMT

DFINITY 入門: Motoko プログラミングの始め方

Wed, 18 May 2022 19:38:00 GMT

このページは、DFINITY(Internet Computer) の Motoko Language チュートリアルを日本語で解説しています。

Explore the default project

実際に使ったソースコードはGitHubからダウンロードできます。

はじめての方は先にこちらをご覧ください。

5 ステップではじめる Motoko プログラミング入門

実行環境

dfx: 0.8.4
macOS: 11.5.2
npm version: 8.1.3

手順

プロジェクトの作成

新しいプロジェクトを作ります。

dfx new explore_hello

以下のようなファイルが作られていれば OK です。

explore_hello % ls explore_hello
README.md               node_modules            package.json            webpack.config.js
dfx.json                package-lock.json       src

このプロジェクトで使うソースコードはsrc/explore_hello/main.moに書かれています。

actor {
    public func greet(name : Text) : async Text {
        return "Hello, " # name # "!";
    };
};

greet()という関数に文字列を渡すと Hello, <文字列>!を返す簡単なプログラムです。

ローカル実行環境の起動

以下のコマンドを実行して、ローカル PC 上に実行環境を起動します。 dfx.json ファイルがあるディレクトリで dfx コマンドを実行してください。

cd explore_hello
dfx start

以下のようにログが出力されれば成功です。

 INFO Starting server. Listening on http://127.0.0.1:8000/

もし、すでに 8000 番ポートを使っている場合は起動できません。

キャニスターの作成

キャニスターとは、スマートコントラクトの入れ物です。直訳すると空き缶という意味で、ここでは空の入れ物をまず作るイメージです。 dfx.json があるプロジェクトディレクトリ上で dfx コマンドを実行します。

cd explore_hello
dfx canister create --all

以下のように出力されます。

The wallet canister on the "local" network for user "default" is "rwlgt-iiaaa-aaaaa-aaaaa-cai"
Creating canister "explore_hello"...
"explore_hello" canister created with canister id: "rrkah-fqaaa-aaaaa-aaaaq-cai"
Creating canister "explore_hello_assets"...
"explore_hello_assets" canister created with canister id: "ryjl3-tyaaa-aaaaa-aaaba-cai"

最初にdfx startでlocalに起動したローカル実行環境に defaultユーザーによって 2 つのキャニスターが作られました。

作られたキャニスターを識別するための ID が割り振られます。今後キャニスターを指定するときにはこの ID を使います。この ID は .dfx/local/canister_ids.json というファイルに保存されています。

cat.dfx / local / canister_ids.json;

{
  "explore_hello": {
    "local": "rrkah-fqaaa-aaaaa-aaaaq-cai"
  },
  "explore_hello_assets": {
    "local": "ryjl3-tyaaa-aaaaa-aaaba-cai"
  }
}

ビルド

ソースコードをビルドします。

dfx build

Motoko で書かれたソースコードをコンパイルして WASM という実行モジュールをビルドしています。

explore_hello % dfx build
Building canisters...
Building frontend...

デプロイ

先ほどビルドして作成した WASM モジュールを実行環境にデプロイします。

dfx canister install --all

Internet Computer に作った空き缶（キャニスター）の中に、WASM という実行プログラムを入れるイメージです。

explore_hello % dfx canister install --all
Creating UI canister on the local network.
The UI canister on the "local" network is "r7inp-6aaaa-aaaaa-aaabq-cai"
Installing code for canister explore_hello, with canister_id rrkah-fqaaa-aaaaa-aaaaq-cai
Installing code for canister explore_hello_assets, with canister_id ryjl3-tyaaa-aaaaa-aaaba-cai
Authorizing our identity (default) to the asset canister...
Uploading assets to asset canister...
Starting batch.
Staging contents of new and changed assets:
  /favicon.ico 1/1 (15406 bytes)
  /index.html 1/1 (671 bytes)
  /index.html (gzip) 1/1 (386 bytes)
  /index.js 1/1 (604206 bytes)
  /index.js (gzip) 1/1 (144664 bytes)
  /main.css 1/1 (537 bytes)
  /main.css (gzip) 1/1 (297 bytes)
  /sample-asset.txt 1/1 (24 bytes)
  /logo.png 1/1 (25397 bytes)
  /index.js.map 1/1 (653971 bytes)
  /index.js.map (gzip) 1/1 (148954 bytes)
Committing batch.

ローカルの実行環境にキャニスターをデプロイしました。

実行

キャニスターを実行してみましょう。

explore_hello % dfx canister call explore_hello greet '("everyone": text)'

explore_helloはキャニスターの名前です。裏側ではキャニスター ID で管理されています。 greet()という関数に"everyone"という text 型の文字列を渡しています。

結果
("Hello, everyone!")

ローカル実行環境の停止

以下のいずれかの方法でローカル PC の実行環境を停止できます。

dfx start を実行したターミナルで Ctrl+C を実行
dfx.json があるディレクトリ上で以下のコマンドを実行

dfx stop

Internet Computer の世界へようこそ

公式のチュートリアルや Examples を日本語で解説しています。

5 ステップではじめる Motoko プログラミング入門

NFT プログラミング入門: OpenZeppelin ライブラリを使った ERC721 コントラクト

Mon, 02 May 2022 21:00:00 GMT

このページはこんな人におすすめ

Solidity を学びたい
NFT のプログラミングを学習したい
簡単なスマートコントラクトの作り方を知りたい

新しい Hardhat プロジェクトを作る

open-zeppelin-erc721 というディレクトリを作り npm パッケージの hardhat をインストールします。

mkdir open-zeppelin-erc721
cd open-zeppelin-erc721
npm init -y
npm i --save-dev hardhat

Hardhat のサンプルプロジェクトを作ります。

npx hardhat

Create a sample projectを選択して、すべて Yes で回答します。

? What do you want to do? …
❯ Create a sample project
  Create an empty hardhat.config.js
  Quit

OpenZeppelin ライブラリのインストール

npm install -D hardhat @openzeppelin/contracts

コーディング

OpenZeppelin (ERC721)

contracts/GameItem.sol

// contracts/GameItem.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract GameItem is ERC721URIStorage {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor() ERC721("GameItem", "ITM") {}

    function awardItem(address player, string memory tokenURI)
        public
        returns (uint256)
    {
        uint256 newItemId = _tokenIds.current();
        _mint(player, newItemId);
        _setTokenURI(newItemId, tokenURI);

        _tokenIds.increment();
        return newItemId;
    }
}

hardhat.config.js

require("@nomiclabs/hardhat-waffle");

// This is a sample Hardhat task. To learn how to create your own go to
// https://hardhat.org/guides/create-task.html
task("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
  const accounts = await hre.ethers.getSigners();

  for (const account of accounts) {
    console.log(account.address);
  }
});

// You need to export an object to set up your config
// Go to https://hardhat.org/config/ to learn more

/**
 * @type import('hardhat/config').HardhatUserConfig
 */
module.exports = {
  solidity: "0.8.6",
};

Solidity 入門: NFT プログラミング (ERC721)

Mon, 02 May 2022 19:00:00 GMT

このページはこんな人におすすめ

NFT のプログラミングを学習したい
Solidity を学びたい
簡単なスマートコントラクトの作り方を知りたい
Web3 エンジニアになりたい

このページでは Solidity by Example のサンプルコードを使ってスマートコントラクトを作る方法を解説します。

以下のページでほかのサンプルコードも解説しています。

Hardhat を使ったことがない方は以下の記事も合わせてご覧ください。

Hardhat の使い方: 初心者向けのスマートコントラクト開発

事前準備

今回はテスト版の OpenSea がある Rinkeby にデプロイします。 JavaScript の開発ツールである npm と npx をインストールした環境で開発します。

npm & npx コマンド
テストネット Rinkeby の ETH トークン

Rinkeby のエンドポイントと秘密鍵を環境変数で設定しておきます。

RINKEBY_PRIVATE_KEY: ウォレットの秘密鍵
RINKEBY_RPC_URL: Rinkeby の RPC エンドポイント

環境変数の使い方については以下の記事をご覧ください

Hardhat の使い方: Ethereum のテストネットにデプロイしよう！

新しい Hardhat プロジェクトを作る

erc721 というディレクトリを作り npm パッケージの hardhat をインストールします。

mkdir erc721
cd erc721
npm init -y
npm i --save-dev hardhat

Hardhat のサンプルプロジェクトを作ります。

npx hardhat

Create a sample projectを選択して、すべて Yes で回答します。

? What do you want to do? …
❯ Create a sample project
  Create an empty hardhat.config.js
  Quit

コーディング

以下の 3 つのファイルを作ります。

hardhat.config.js
contracts/erc721.sol
scripts/deploy.js

hardhat.config.js

require("@nomiclabs/hardhat-waffle");

const RINKEBY_PRIVATE_KEY = process.env.RINKEBY_PRIVATE_KEY;
const RINKEBY_RPC_URL = process.env.RINKEBY_RPC_URL;

/**
 * @type import('hardhat/config').HardhatUserConfig
 */
module.exports = {
  solidity: "0.8.6",
  networks: {
    rinkeby: {
      url: `${RINKEBY_RPC_URL}`,
      accounts: [`${RINKEBY_PRIVATE_KEY}`],
    },
  },
};

contracts/erc721.sol

Solidity by Example のサンプルコードを丸ごとコピペして contracts/erc721.sol を作ります。

Solidity by Example (ERC721)

secripts/deploy.js

const hre = require("hardhat");

async function main() {
  const Factory = await hre.ethers.getContractFactory("ERC721");
  const contract = await Factory.deploy();
  await contract.deployed();

  console.log("Contract deployed to:", contract.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

コンパイル＆デプロイ

以下のコマンドでコンパイルします。

npx hardhat compile

以下のように表示されればコンパイル成功です。

Compiled 1 Solidity file successfully

環境変数を設定した状態で以下のコマンドでデプロイします。

# 環境変数を書いたファイルを読み込む
source env.txt

# デプロイ
npx hardhat run scripts/deploy.js --network rinkeby

以下のように表示されれば、デプロイ成功です。

Contract deployed to: 0x2789eE319C74dd5bd9b3E46E2B89Ba2E07cC7D88

確認

Rinkeby の Etherscan でデプロイしたコントラクトを確認してみましょう。

https://rinkeby.etherscan.io/address/0x2789eE319C74dd5bd9b3E46E2B89Ba2E07cC7D88

このページで実際に使ったソースコードはGitHubからダウンロードできます。

Solidity 入門: イーサリアムアプリ開発 Dapps プログラミング

Fri, 29 Apr 2022 21:00:00 GMT

このページはこんな人におすすめ

Solidity を学びたい
簡単なスマートコントラクトの作り方を知りたい
Hardhat を使った Solidity のテスト方法を知りたい

このページで実際に使ったソースコードはGitHubからダウンロードできます。

Solidity by Example のサンプルコードを使ってスマートコントラクトを作る方法を解説します。

First Application (Solidity by Example)

Hardhat を使ったことがない方は先にこちらもご覧ください。

Hardhat の使い方: 初心者向けのスマートコントラクト開発

新しい Hardhat プロジェクトを作る

first-app というディレクトリを作り npm パッケージの hardhat をインストールします。

mkdir first-app
cd first-app
npm init -y
npm i --save-dev hardhat

Hardhat のサンプルプロジェクトを作ります。

npx hardhat

Create a sample projectを選択して、すべて Yes で回答します。

? What do you want to do? …
❯ Create a sample project
  Create an empty hardhat.config.js
  Quit

これで hardhat.config.js の初期設定や ether.js などプラグインを追加した状態になります。

コーディング

contracts/Counter.sol と hardhat.config.js を編集します。 2 つの Solidity バージョンが一致するようにしましょう。

contracts/Counter.sol

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

contract Counter {
    uint public count;

    // Function to get the current count
    function get() public view returns (uint) {
        return count;
    }

    // Function to increment count by 1
    function inc() public {
        count += 1;
    }

    // Function to decrement count by 1
    function dec() public {
        count -= 1;
    }
}

2022 年 1 月現在、サンプルコードのバージョンは 0.8.10 になっており、 Hardhat 側は 0.8.9 まで対応中なので、0.8.9 に合わせます。

hardhat.config.js の一部

module.exports = {
  solidity: "0.8.9",
};

テスト

Hardhat では JavaScript のテストツールの chai を使っています。 sample-test.js を以下のように編集します。

test/sample-test.js

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Counter", function () {
  let Factory;
  let contract;

  // 各テストの前に毎回デプロイ処理が走ります
  beforeEach(async function () {
    Factory = await ethers.getContractFactory("Counter");
    contract = await Factory.deploy();
  });

  // 初期状態でget()の戻り値が0であること
  it("Should be 0", async function () {
    expect(await contract.get()).to.equal(0);
  });

  // inc()を実行すると+1されること
  it("Should be 1 after inc()", async function () {
    const Tx = await contract.inc();
    await Tx.wait();
    expect(await contract.get()).to.equal(1);
  });

  // dec()を実行すると-1されること
  it("Should be 0 after inc() and dec()", async function () {
    const Tx1 = await contract.inc();
    await Tx1.wait();
    expect(await contract.get()).to.equal(1);
    const Tx2 = await contract.dec();
    await Tx2.wait();
    expect(await contract.get()).to.equal(0);
  });
});

テスト実行

以下のコマンドを実行すると test ディレクトリ配下にあるテストが実行されます。

npx hardhat test

出力
  Counter
    ✓ Should be 0
    ✓ Should be 1 after inc()
    ✓ Should be 0 after inc() and dec()


  3 passing (406ms)

3 つのテストがすべて Pass(成功)となりました。

デプロイ（ローカル実行環境）

scripts/deploy.js というファイルを作ります。このファイルはローカル実行環境あるいはパブリックブロックチェーンにデプロイしたり、スマートコントラクトの関数を実行したりする処理を記述します。

scripts/deploy.js

const hre = require("hardhat");

async function main() {
  const Factory = await hre.ethers.getContractFactory("Counter");
  const contract = await Factory.deploy();
  await contract.deployed();

  console.log("Contract deployed to:", contract.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

以下のコマンドでデプロイを実行します。

npx hardhat run scripts/deploy.js

出力
Contract deployed to: 0x5FbDB2315678afecb367f032d93F642f64180aa3

これでローカル実行環境にデプロイできました。

ローカル実行県境で試したら、つぎはパブリックテストネットにデプロイしてみましょう。

デプロイ（テストネット）

ブロックチェーンには本番用のメインネットと検証用のテストネットがあります。

Ethereum には複数のテストネットがあり、誰でもトークンをもらうことができます。

Ropsten
Rinkeby
Kovan
Goerli

スマートコントラクトをテストネットやメインネットにデプロイする方法を 2 つ紹介します。

Motoko Base Library

Fri, 29 Apr 2022 10:38:00 GMT

Motoko Language Tour

https://internetcomputer.org/docs/current/motoko/main/motoko

Motoko Programming Language Guide

https://internetcomputer.org/docs/current/motoko/main/about-this-guide

Sample Code

https://internetcomputer.org/samples

https://github.com/dfinity/examples/tree/master/motoko

Motoko Base Library Reference

NFT プログラミング入門: いろんな NFT の実装方法の分類

Sun, 24 Apr 2022 21:00:00 GMT

このページはこんな人におすすめ

NFT の実装の分類が知りたい
独自スマートコントラクトの NFT を作りたい

NFT では ERC721 や ERC1155 という共通の仕様がありますが、その機能によって実装方法はいろいろあります。

それらを分類して作り方を紹介しているサイトをまとめました。

NFT の種類は無数に存在しますが、ここでは 2021~2022 年に開発が活発になっている NFT について紹介します。

OpenSea で発行
ジェネラティブ NFT
Loot
フルオンチェーン(SVG/Bitmap/オリジナル）

おまけでノーコードのサービスも載せておきます。エンジニアじゃなくても画面をポチポチするだけで ERC721 や ERC1155 のスマートコントラクトをメインネットにデプロイできます。

どのブロックチェーンがいいの？

チェーンはたくさんありますが、学習目的の場合にオススメなのは Ethereum のテストネット(Rinkeby)です。

どのブロックチェーンを使うか決まっていないのなら、まずは EVM(Ethereum Virtual Machine)に取り組むのが良いでしょう。

理由は、開発者もユーザー数も最大で技術と市場が一番成長しているからです。

テスト用の OpenSea があるため、発行した NFT を OpenSea で見ることができます。

ERC721/1155

EVM で発行される NFT は、ERC721 または ERC1155 のスマートコントラクトと言い換えることができます。

あとから紹介するジェネラティブ, Loot, フルオンチェーンも ERC721 または ERC1155 に従っています。

NFT を作る場合に、一番簡単な方法は、OpenSea から発行する方法です。

OpenSea で発行する場合は OpenSea が所有する ERC1155 のコントラクトです。(2022 年 1 月現在)

独自コントラクトでも ERC721 や ERC1155 のフォーマットに合わせていれば OpenSea や他のマーケットプレイスで売買することができます。

OpenSea (Testnet)

https://testnets.opensea.io/

テストネット用の ETH は無料で入手できますが、不安定なので動いているときと動いていないときがあります。

Faucet (Rinkeby)

https://faucet.rinkeby.io/

Chainlink の Faucet からでも Rinkeby の ETH をもらうことができます。

Faucet Chainlink

https://faucets.chain.link/rinkeby

OpenSea で作る場合は、スマートコントラクトの所有者は OpenSea です。もし OpenSea で作った NFT に不便を感じていないならいまは独自コントラクトをつくる必要はないでしょう。

もし、ユーザーに直接 mint してもらう NFT や、フルオンチェーンの NFT を作りたい場合は、OpenSea では作れません。そういう NFT を作る時には独自のスマートコントラクトをデプロイして NFT を発行します。

【2021 年版】NFT を発行してほしいという問い合わせが多いので発行方法とサンプルコードを公開します

NFT 完全に理解した！！になるために独自コントラクトで NFT を発行してみる方法の解説

ジェネラティブ NFT

画像を組み合わせてユニークな画像を 10,000 枚使った NFT の作り方の紹介です。

（保存版）10,000 種類のジェネレイティブ NFT の作り方

Loot

Loot は画像の代わりに文字情報を持った NFT です。発行する NFT の Token ID ごとに異なるパラメータを持たせることができます。創造力次第で可能性が広がる NFT ですね。

【Solidity】Loot 型の NFT をつくってみよう！

フルオンチェーン（SVG）

フルオンチェーンは名前のとおり、データをオンチェーンに載せています。

PNG や JPEG などの画像を使った NFT の場合は、画像ファイルをチェーンには載せない方法が一般的です。理由は、オンチェーンにこれらの画像データを載せるとストレージコストが高いためです。

SVG というフォーマットの画像を動的に生成する特性を活かしてスマートコントラクトで SVG を生成します。その結果、外部のファイルを使うことなくすべてのデータをオンチェーンに載せたフルオンチェーン NFT となります。

【保存版】フルオンチェーン NFT の作り方_完全版（入門レベル）

【保存版】SVG 徹底解説！アニメーション・フルオンチェーン NFT を作ろう！

フルオンチェーン（Bitmap）

Bitmap は画像の 1 ドットごとに色情報を持つ原始的な画像フォーマットです。高精細な画像の場合はデータが大きくなりますが、あえて Bitmap で画素数の少ないドット絵を表現しています。原始的な手法ゆえに、いかに容量を節約したり表現を豊かにしたりするかプログラマの腕の見せ所です。

full-on-chain pixel art NFT

フルオンチェーン（オリジナル）

最後にスマートコントラクトの特徴を活かした遊び心のある NFT の記事を紹介します。

おみくじ NFT を作りました

100 時間後に死ぬ NFT を作りました

ノーコード(おまけ)

thirdweb を使うと ERC20, ERC721, ERC1155 など汎用的なスマートコントラクトをノーコードでデプロイできます。

thirdweb

おわりに

ここで紹介しているページは、プロの自分から見た信頼できる技術者の情報を選んでいます。

素晴らしい記事を作成してくださったエンジニア著者の皆さまに敬意と感謝の気持ちを込めて

ICP プログラミング入門: Rust ではじめてのキャニスター開発

Sun, 24 Apr 2022 19:38:00 GMT

このページはこんな人におすすめ

Rust を勉強したい
DFINITY(ICP) の開発に興味がある

このページは、以下の DFINITY(Internet Computer) の Rust のチュートリアルを日本語で解説しています。

Hello, World! Rust CDK Quick Start

このページで実際に使ったソースコードはGitHubからダウンロードできます。

実行環境

dfx: 0.8.4
macOS: 11.5.2
rustup: 1.24.3
rustc: 1.57.0
cargo: 1.57.0

インストール

dfx のインストール

dfx コマンドは DFINITY のキャニスターをビルドしたりデプロイしたりするためのツールです。

dfx のインストールガイド

以下のコマンドで dfx をインストールします。

sh -ci "$(curl -fsSL https://sdk.dfinity.org/install.sh)"

rustup (Rust Toolchain)

以下のコマンドによって Rust 系のツールをまとめてインストールします。

curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

rustc: Rust コンパイラ
cargo: Rust のパッケージマネージャ
rustup: Rust のビルドツール全体を管理

CMake のインストール

以下のコマンドで cmake をインストールします。

brew install cmake

プロジェクトの作成

DFINITY のデフォルトの開発言語は Motoko です。 --type=rustをつけて Rust 用のプロジェクトを作成します。

dfx new --type=rust rust_hello
cd rust_hello

dfx.json というファイルを見てみましょう。 dfx コマンドでビルドするときにはこのファイルの設定が使われます。

dfx.json

{
  "canisters": {
    "rust_hello": {
      "candid": "src/rust_hello/rust_hello.did",
      "package": "rust_hello",
      "type": "rust"
    },
    "rust_hello_assets": {
      "dependencies": [
        "rust_hello"
      ],
      "frontend": {
        "entrypoint": "src/rust_hello_assets/src/index.html"
      },
      "source": [
        "src/rust_hello_assets/assets",
        "dist/rust_hello_assets/"
      ],
      "type": "assets"
    }
  },
  "defaults": {
    "build": {
      "args": "",
      "packtool": ""
    }
  },
  "networks": {
    "local": {
      "bind": "127.0.0.1:8000",
      "type": "ephemeral"
    }
  },
  "version": 1
}

キャニスター(スマートコントラクト)の作成

ソースコード

cargo は Rust のビルドに使うツールです。 Cargo.toml には、cargo で使う設定が書かれています。 rust_hello プロジェクトには、2 つの Cargo.toml があります。

Cargo.toml

[workspace]
members = [
    "src/rust_hello",
]

src/rust_hello/Cargo.toml

[package]
name = "rust_hello"
version = "0.1.0"
edition = "2018"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[lib]
path = "lib.rs"
crate-type = ["cdylib"]

[dependencies]
ic-cdk = "0.3"
ic-cdk-macros = "0.3"

src/rust_hello/lib.rs

スマートコントラクト本体のソースコードです。今回は greet というシンプルな関数だけが書かれています。

#[ic_cdk_macros::query]
fn greet(name: String) -> String {
    format!("Hello, {}!", name)
}

Candid

Candid はキャニスターのインターフェースの情報が書かれており、フロントエンドからキャニスターを実行するときにはこのインターフェースの情報を利用します。

service : {
    "greet": (text) -> (text) query;
}

この場合は、greet という query があり、引数と戻りは text です。

ビルド&デプロイ

PC 上にローカル実行環境を起動します。

dfx start --background

WASM にはいろんなフォーマットがあるため、DFINITY 用の WASM32 を追加します。

rustup target add wasm32-unknown-unknown

Rust の WASM キャニスターをビルドしてローカル実行環境にデプロイします。

dfx deploy

出力
Creating a wallet canister on the local network.
The wallet canister on the "local" network for user "alice_auth" is "rwlgt-iiaaa-aaaaa-aaaaa-cai"
Deploying all canisters.
Creating canisters...
Creating canister "rust_hello"...
（中略）
Committing batch.
Deployed canisters.

キャニスターの実行

rust_hello というキャニスターの greet()という関数に world という引数を渡して実行します。

dfx canister call rust_hello greet world

出力
("Hello, world!")

フロントエンドの起動

公式手順には載っていませんが、Motoko のチュートリアルと同様にフロントエンドを起動して、フロントエンドからキャニスターを実行することもできます。

npm install
npm start

http://localhost:8080

停止

ローカル実行環境を停止します。

dfx stop

Rust エンジニアへの第一歩を踏み出しました！ソースコードを変えていろんなキャニスターを作ってみましょう。

ウォレットいらずのスマートコントラクト開発 | はじめてのイーサリアム開発

Wed, 20 Apr 2022 21:00:00 GMT

このページはこんな人におすすめ

スマートコントラクト開発を始める
ブロックチェーン開発に興味がある
Dapps や Web3 に興味がある

ブロックチェーンを使った開発をまったくやったことがない方に向けて書いています。 npm という JavaScript のパッケージ管理ツールさえあれば実行できます。

本記事で学べること

Solidity という言語を使って Hello World のスマートコントラクトを作ります。ローカル実行環境に作るところから始めましょう。ローカル実行環境には Hardhat という開発ツールを使います。

スマートコントラクトの開発は、ブロックチェーンと開発言語を選ぶことになります。 2022 年現在、もっとも開発が活発に進んでいるのは Ethereum です。

Ethereum のスマートコントラクトは EVM（Ethereum Virtual Machine）で実行されます。

EVM と WASM

スマートコントラクトの実行形式は大まかに EVM と WASM(WebAssembly)の２つに分類できます。

EVM のスマートコントラクトの開発言語は Solidity です。

EVM 対応のブロックチェーンは互換性があり、別のチェーンでも同じソースコードを使えます。例えば、Ethereum 用のスマートコントラクトのソースコードを Polygon でそのまま使うことができます。

WASM 対応のブロックチェーンは、チェーンごとにそれぞれの特徴があるので、スマートコントラクトのソースコードを使い回すことはできません。

現在は WASM にコンパイルする開発言語は Rust が主流ですが、技術的には WASM にコンパイルできればどんな言語も使えます。

必要なもの

npm & npx コマンド
好みのテキストエディタ
好みのターミナルソフト

新しい Hardhat プロジェクトを作る

hello というディレクトリを作り npm パッケージの hardhat をインストールします。

mkdir hello
cd hello
npm init -y
npm i --save-dev hardhat

Hardhat のサンプルプロジェクトを作ります。

npx hardhat

Create a sample projectを選択して、すべて Yes で回答します。

? What do you want to do? …
❯ Create a sample project
  Create an empty hardhat.config.js
  Quit

これで hardhat.config.js の初期設定や ether.js などプラグインを追加した状態になります。

コーディング

contracts/Greeter.sol を以下のように編集します。

contracts/Greeter.sol

// SPDX-License-Identifier: MIT
// compiler version must be greater than or equal to 0.8.10 and less than 0.9.0
pragma solidity ^0.8.9;

contract Greeter {
    string public greet = "Hello World!";

    function hello() external view returns (string memory) {
        return greet;
    }
}

コンパイル

Solidity のソースコードを Hardhat のコンパイラでコンパイルします。以下のコマンドを実行します。

npx hardhat compile

出力
Compiling 1 file with 0.8.9
Compilation finished successfully

デプロイ

script/sample-script.js を以下のように編集します。

script/sample-script.js

const hre = require("hardhat");

async function main() {
  const Greeter = await hre.ethers.getContractFactory("Greeter");
  const greeter = await Greeter.deploy();

  await greeter.deployed();

  console.log("Greeter deployed to:", greeter.address);
  const ret = await greeter.hello();
  console.log(ret);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

このスクリプトでは、ローカル実行環境にデプロイしたあとにスマートコントラクトの hello()という関数を実行します。

実行

以下のコマンドで実行します。

 % npx hardhat run scripts/sample-script.js

出力
Greeter deployed to: 0x5FbDB2315678afecb367f032d93F642f64180aa3
Hello World!

hello()関数を実行して、受け取った文字列Hello World!をログに表示できました。

これでスマートコントラクトエンジニアです！

次はスマートコントラクトをブロックチェーンにデプロイして実行してみよう。

スマートコントラクトをテストネットやメインネットにデプロイする方法を 2 つ紹介します。自分にあったやり方を見つけてください。

はじめての Solana: Rust で Hello World!

Tue, 19 Apr 2022 21:00:00 GMT

このページはこんな人におすすめ

Rust で簡単なスマートコントラクトを実装してみたい
Solana に興味がある

このページは、Solana の Hello World を日本語で解説します。

https://docs.solana.com/developing/on-chain-programs/examples

はじめにドキュメント通りの手順を一通り行ったあとで、後半では必要最小限のコードだけを抽出して、ラップされているビルドやデプロイのコマンドを紹介しています。

事前準備

Solana の devnet または testnet を使います。devnet や testnet のトークンが必要ですが無料で取得できます。はじめての方はこちらのページをご覧ください。

Solana 開発のための環境構築

実行環境

macOS 11.5.2
npm 8.5.1
solana-cli 1.8.5

ドキュメントの手順を一通りやってみる

まずはドキュメントの通りに一通りやってみましょう。 Solana Labs の example-helloworld というプロジェクトがあります。これを git clone します。

% git clone https://github.com/solana-labs/example-helloworld.git
% cd example-helloworld

README に書かれているように、npm でライブラリをインストールします。

% npm install

README では localhost でテスト用の環境を作って deploy していますが、筆者の M1 Mac では localhost でうまく動かないので、testnet にデプロイします。

筆者の solana-cli の config では以下のように設定しています。

% solana config get
Config File: /Users/sakanosita/.config/solana/cli/config.yml
RPC URL: https://api.testnet.solana.com
WebSocket URL: wss://api.devnet.solana.com/ (computed)
Keypair Path: /Users/sakanosita/.config/solana/Kagetoki.json
Commitment: confirmed

プロジェクトに最初から用意されている、Rust のコードをビルドします。

% npm run build:program-rust

devnet にデプロイします。

% solana program deploy dist/program/helloworld.so
Program Id: HLBxKXnRMaoBxWs3GxUMR78k9if1if7UPqWUJqGGAhCw

実行してみましょう。

% npm run start

> helloworld@0.0.1 start
> ts-node src/client/main.ts

Let's say hello to a Solana account...
Connection to cluster established: https://api.testnet.solana.com { 'feature-set': 1122441720, 'solana-core': '1.10.8' }
Using account 9HTsYGKHNBjHDnChwVBtdn6f61gWFnSuc5yYfixL1Wfp containing 0.1551188 SOL to pay for fees
Using program HLBxKXnRMaoBxWs3GxUMR78k9if1if7UPqWUJqGGAhCw
Creating account CFWdJJs3ixaLZevwirLHQCpRLKuhB9oDfqryBneA2YX8 to say hello to
Saying hello to CFWdJJs3ixaLZevwirLHQCpRLKuhB9oDfqryBneA2YX8
CFWdJJs3ixaLZevwirLHQCpRLKuhB9oDfqryBneA2YX8 has been greeted 1 time(s)
Success

これで testnet にデプロイした helloworld というスマートコントラクトを正常に実行できました。 Testnet のエクスプローラで Program Id を検索するとログを見ることができます。

https://explorer.solana.com/address/HLBxKXnRMaoBxWs3GxUMR78k9if1if7UPqWUJqGGAhCw?cluster=testnet

続いて、ここまでの手順を分解してゼロからコードを作ってみましょう。

プロジェクトの作成

新しい Cargo プロジェクトを作ります。

Solana Labs の example では C 言語と Rust 言語の両方のソースコードが入っていましたが、今回は Rust だけのプロジェクトを作りましょう！

プロジェクト名は rust-hello-world にします。

% cargo new rust-hello-world
% cd rust-hello-world

以下のようなファイルが作られています。

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

コーディング

Cargo.toml

[package]
name = "rust-hello-world"
version = "0.0.1"
description = "Example template program written in Rust"
authors = ["Solana Maintainers <maintainers@solana.com>"]
repository = "https://github.com/smacon-dev/solana"
license = "Apache-2.0"
homepage = "https://smacon.dev/"
edition = "2022"

[features]
no-entrypoint = []

[dependencies]
borsh = "0.9.3"
borsh-derive = "0.9.1"
solana-program = "~1.8.14"

[dev-dependencies]
solana-program-test = "~1.8.14"
solana-sdk = "~1.8.14"

[lib]
name = "helloworld"
crate-type = ["cdylib", "lib"]

src/lib.rs

use borsh::{BorshDeserialize, BorshSerialize};
use solana_program::{
    account_info::{next_account_info, AccountInfo},
    entrypoint,
    entrypoint::ProgramResult,
    msg,
    program_error::ProgramError,
    pubkey::Pubkey,
};

/// Define the type of state stored in accounts
#[derive(BorshSerialize, BorshDeserialize, Debug)]
pub struct GreetingAccount {
    /// number of greetings
    pub counter: u32,
}

// Declare and export the program's entrypoint
entrypoint!(process_instruction);

// Program entrypoint's implementation
pub fn process_instruction(
    program_id: &Pubkey, // Public key of the account the hello world program was loaded into
    accounts: &[AccountInfo], // The account to say hello to
    _instruction_data: &[u8], // Ignored, all helloworld instructions are hellos
) -> ProgramResult {
    msg!("Hello World Rust program entrypoint");

    // Iterating accounts is safer than indexing
    let accounts_iter = &mut accounts.iter();

    // Get the account to say hello to
    let account = next_account_info(accounts_iter)?;

    // The account must be owned by the program in order to modify its data
    if account.owner != program_id {
        msg!("Greeted account does not have the correct program id");
        return Err(ProgramError::IncorrectProgramId);
    }

    // Increment and store the number of times the account has been greeted
    let mut greeting_account = GreetingAccount::try_from_slice(&account.data.borrow())?;
    greeting_account.counter += 1;
    greeting_account.serialize(&mut &mut account.data.borrow_mut()[..])?;

    msg!("Greeted {} time(s)!", greeting_account.counter);

    Ok(())
}

// Sanity tests
#[cfg(test)]
mod test {
    use super::*;
    use solana_program::clock::Epoch;
    use std::mem;

    #[test]
    fn test_sanity() {
        let program_id = Pubkey::default();
        let key = Pubkey::default();
        let mut lamports = 0;
        let mut data = vec![0; mem::size_of::<u32>()];
        let owner = Pubkey::default();
        let account = AccountInfo::new(
            &key,
            false,
            true,
            &mut lamports,
            &mut data,
            &owner,
            false,
            Epoch::default(),
        );
        let instruction_data: Vec<u8> = Vec::new();

        let accounts = vec![account];

        assert_eq!(
            GreetingAccount::try_from_slice(&accounts[0].data.borrow())
                .unwrap()
                .counter,
            0
        );
        process_instruction(&program_id, &accounts, &instruction_data).unwrap();
        assert_eq!(
            GreetingAccount::try_from_slice(&accounts[0].data.borrow())
                .unwrap()
                .counter,
            1
        );
        process_instruction(&program_id, &accounts, &instruction_data).unwrap();
        assert_eq!(
            GreetingAccount::try_from_slice(&accounts[0].data.borrow())
                .unwrap()
                .counter,
            2
        );
    }
}

ビルド＆デプロイ

先程は、npm でラップしてビルドしていましたが、実際にビルドで使われているのは Rust の開発ツールの cargo コマンドです。

cargo のマニフェスト Cargo.toml はカレントディレクトリにある場合は、指定する必要はありません。出力先のディレクトリだけ指定しましょう。

% cargo build-bpf --bpf-out-dir=dist/program

solana-cli で devnet または testnet にデプロイします。

% solana program deploy dist/program/helloworld.so

クライアント用ディレクトリの作成

Solana のスマートコントラクトは TypeScript(JavaScript)から実行します。

先ほどの Cargo プロジェクトの中にクライアントプログラム用のディレクトリを作成します。

% mkdir client
% cd client

npm ライブラリのインストール

以下のコマンドを実行してライブラリをインストールします。

% npm install -D typescript ts-node @types/mz
% npm install @solana/web3.js yaml

すると以下のように package.json ができます。

{
  "devDependencies": {
    "@types/mz": "^2.7.4",
    "ts-node": "^10.7.0",
    "typescript": "^4.6.3"
  },
  "dependencies": {
    "@solana/web3.js": "^1.39.1",
    "yaml": "^2.0.1"
  }
}

コーディング（クライアント）

client/srcディレクトリの中に３つの TypeScript ファイルを作ります。

main.ts
hello_world.ts
utils.ts

Solana Labs の example をコピーしましょう。

client % tree src
src
├── hello_world.ts
├── main.ts
└── utils.ts

実行

カレントディレクトリが client ディレクトリの状態で npx コマンドを使って ts-node を実行します。

 % npx ts-node src/main.ts
Let's say hello to a Solana account...
Connection to cluster established: https://api.testnet.solana.com { 'feature-set': 1122441720, 'solana-core': '1.10.8' }
Using account 9HTsYGKHNBjHDnChwVBtdn6f61gWFnSuc5yYfixL1Wfp containing 1.61226932 SOL to pay for fees
Using program 52cSCaoULTpw1HrUHUnjAYHq6jTeVWLoWWj3MvazCbSs
Saying hello to Aw6Pwy8mQQBBaK4UcMUgF4UzZGFWqUKUfDLdR3jjYXZm
Aw6Pwy8mQQBBaK4UcMUgF4UzZGFWqUK

これで実行完了です。

この記事で使った実際のコードはGitHubで公開しています。

NEAR Protocol: はじめてのスマートコントラクト in Rust

Mon, 18 Apr 2022 19:38:00 GMT

このページはこんな人におすすめ

Rust で簡単なスマートコントラクトを実装してみたい
NEAR Protocol に興味がある

このページは、NEAR Protocol の Rust のチュートリアルを日本語で解説しています。

Building a Smart Contract in Rust

事前準備

NEAR のテストネット用のアカウントとテストネットの NEAR トークンが必要です。

https://wallet.testnet.near.org/

実行環境

macOS 11.5.2
npm 8.5.1
rustup: 1.24.3
rustc: 1.60.0
cargo: 1.60.0

near-cli のインストール

開発用の Mac へ NEAR の開発ツール near-cli をインストールします。

$ npm install -g near-cli

成功すると以下のように near コマンドを実行できるようになります。

$ near --version
3.2.0

新しいプロジェクトの作成

cargo コマンドで新しいプロジェクトを作ります。

$ cargo new rust-counter-tutorial
$ cd rust-counter-tutorial

以下のようなファイルが作られます。

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

ソースコード

自動生成されたファイルから以下のようにファイルを作り変えます。

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

Cargo.toml

[package]
name = "rust-counter-tutorial"
version = "0.1.0"
authors = ["NEAR Inc <hello@near.org>"]
edition = "2018"

[lib]
crate-type = ["cdylib", "rlib"]

[dependencies]
near-sdk = "3.1.0"

[profile.release]
codegen-units = 1
# Tell `rustc` to optimize for small code size.
opt-level = "z"
lto = true
debug = false
panic = "abort"
# Opt into extra safety checks on arithmetic operations https://stackoverflow.com/a/64136471/249801
overflow-checks = true

src/lib.rs


//! This contract implements simple counter backed by storage on blockchain.
//!
//! The contract provides methods to [increment] / [decrement] counter and
//! [get it's current value][get_num] or [reset].
//!
//! [increment]: struct.Counter.html#method.increment
//! [decrement]: struct.Counter.html#method.decrement
//! [get_num]: struct.Counter.html#method.get_num
//! [reset]: struct.Counter.html#method.reset

use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::{env, near_bindgen};

near_sdk::setup_alloc!();

// add the following attributes to prepare your code for serialization and invocation on the blockchain
// More built-in Rust attributes here: https://doc.rust-lang.org/reference/attributes.html#built-in-attributes-index
#[near_bindgen]
#[derive(Default, BorshDeserialize, BorshSerialize)]
pub struct Counter {
    // See more data types at https://doc.rust-lang.org/book/ch03-02-data-types.html
    val: i8, // i8 is signed. unsigned integers are also available: u8, u16, u32, u64, u128
}

#[near_bindgen]
impl Counter {
    /// Returns 8-bit signed integer of the counter value.
    ///
    /// This must match the type from our struct's 'val' defined above.
    ///
    /// Note, the parameter is `&self` (without being mutable) meaning it doesn't modify state.
    /// In the frontend (/src/main.js) this is added to the "viewMethods" array
    /// using near-cli we can call this by:
    ///
    /// ```bash
    /// near view counter.YOU.testnet get_num
    /// ```
    pub fn get_num(&self) -> i8 {
        return self.val;
    }

    /// Increment the counter.
    ///
    /// Note, the parameter is "&mut self" as this function modifies state.
    /// In the frontend (/src/main.js) this is added to the "changeMethods" array
    /// using near-cli we can call this by:
    ///
    /// ```bash
    /// near call counter.YOU.testnet increment --accountId donation.YOU.testnet
    /// ```
    pub fn increment(&mut self) {
        // note: adding one like this is an easy way to accidentally overflow
        // real smart contracts will want to have safety checks
        // e.g. self.val = i8::wrapping_add(self.val, 1);
        // https://doc.rust-lang.org/std/primitive.i8.html#method.wrapping_add
        self.val += 1;
        let log_message = format!("Increased number to {}", self.val);
        env::log(log_message.as_bytes());
        after_counter_change();
    }

    /// Decrement (subtract from) the counter.
    ///
    /// In (/src/main.js) this is also added to the "changeMethods" array
    /// using near-cli we can call this by:
    ///
    /// ```bash
    /// near call counter.YOU.testnet decrement --accountId donation.YOU.testnet
    /// ```
    pub fn decrement(&mut self) {
        // note: subtracting one like this is an easy way to accidentally overflow
        // real smart contracts will want to have safety checks
        // e.g. self.val = i8::wrapping_sub(self.val, 1);
        // https://doc.rust-lang.org/std/primitive.i8.html#method.wrapping_sub
        self.val -= 1;
        let log_message = format!("Decreased number to {}", self.val);
        env::log(log_message.as_bytes());
        after_counter_change();
    }

    /// Reset to zero.
    pub fn reset(&mut self) {
        self.val = 0;
        // Another way to log is to cast a string into bytes, hence "b" below:
        env::log(b"Reset counter to zero");
    }
}

// unlike the struct's functions above, this function cannot use attributes #[derive(…)] or #[near_bindgen]
// any attempts will throw helpful warnings upon 'cargo build'
// while this function cannot be invoked directly on the blockchain, it can be called from an invoked function
fn after_counter_change() {
    // show helpful warning that i8 (8-bit signed integer) will overflow above 127 or below -128
    env::log("Make sure you don't overflow, my friend.".as_bytes());
}

/*
 * the rest of this file sets up unit tests
 * to run these, the command will be:
 * cargo test --package rust-counter-tutorial -- --nocapture
 * Note: 'rust-counter-tutorial' comes from cargo.toml's 'name' key
 */

// use the attribute below for unit tests
#[cfg(test)]
mod tests {
    use super::*;
    use near_sdk::MockedBlockchain;
    use near_sdk::{testing_env, VMContext};

    // part of writing unit tests is setting up a mock context
    // in this example, this is only needed for env::log in the contract
    // this is also a useful list to peek at when wondering what's available in env::*
    fn get_context(input: Vec<u8>, is_view: bool) -> VMContext {
        VMContext {
            current_account_id: "alice.testnet".to_string(),
            signer_account_id: "robert.testnet".to_string(),
            signer_account_pk: vec![0, 1, 2],
            predecessor_account_id: "jane.testnet".to_string(),
            input,
            block_index: 0,
            block_timestamp: 0,
            account_balance: 0,
            account_locked_balance: 0,
            storage_usage: 0,
            attached_deposit: 0,
            prepaid_gas: 10u64.pow(18),
            random_seed: vec![0, 1, 2],
            is_view,
            output_data_receivers: vec![],
            epoch_height: 19,
        }
    }

    // mark individual unit tests with #[test] for them to be registered and fired
    #[test]
    fn increment() {
        // set up the mock context into the testing environment
        let context = get_context(vec![], false);
        testing_env!(context);
        // instantiate a contract variable with the counter at zero
        let mut contract = Counter { val: 0 };
        contract.increment();
        println!("Value after increment: {}", contract.get_num());
        // confirm that we received 1 when calling get_num
        assert_eq!(1, contract.get_num());
    }

    #[test]
    fn decrement() {
        let context = get_context(vec![], false);
        testing_env!(context);
        let mut contract = Counter { val: 0 };
        contract.decrement();
        println!("Value after decrement: {}", contract.get_num());
        // confirm that we received -1 when calling get_num
        assert_eq!(-1, contract.get_num());
    }

    #[test]
    fn increment_and_reset() {
        let context = get_context(vec![], false);
        testing_env!(context);
        let mut contract = Counter { val: 0 };
        contract.increment();
        contract.reset();
        println!("Value after reset: {}", contract.get_num());
        // confirm that we received -1 when calling get_num
        assert_eq!(0, contract.get_num());
    }
}

テストとビルド

以下のコマンドでプログラムのテストを実行できます。

$ cargo test -- --nocapture

以下のコマンドでソースコードから WASM モジュールをコンパイルします。

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

NEAR テストネットへのデプロイ

テストネットにログインします。

$ near login

ビルドした WASM のスマートコントラクトを NEAR テストネットにデプロイします。

$ near deploy --wasmFile target/wasm32-unknown-unknown/release/rust_counter_tutorial.wasm --accountId YOUR_ACCOUNT_HERE

例として sakanosita.testnet を指定する場合

e.g.
$ near deploy --wasmFile target/wasm32-unknown-unknown/release/rust_counter_tutorial.wasm --accountId sakanosita.testnet

実行

デプロイしたスマートコントラクトを実行してみましょう。 get_mum を実行すると現在のカウンタの値を表示して、increment を call するとカウンタを+1 します。

$ near view YOUR_ACCOUNT_HERE get_num --accountId YOUR_ACCOUNT_HERE
$ near call YOUR_ACCOUNT_HERE increment --accountId YOUR_ACCOUNT_HERE

例として increment の実行前後に get_num を実行すると以下のようになります。

e.g.
$ near view sakanosita.testnet get_num --accountId sakanosita.testnet
View call: sakanosita.testnet.get_num()
5

$ near call sakanosita.testnet increment --accountId sakanosita.testnet
Scheduling a call: sakanosita.testnet.increment()
Doing account.functionCall()
Receipt: FrzjQZfPNiHAZCcf9oGUWMG6NKDZRZLktS8LFYZAzjtW
        Log [sakanosita.testnet]: Increased number to 6
        Log [sakanosita.testnet]: Make sure you don't overflow, my friend.
Transaction Id 7dkK3Gmf1ANubsgK4vVsifnVqNqDdcFuC97i9VucyUtE
To see the transaction in the transaction explorer, please open this url in your browser
https://explorer.testnet.near.org/transactions/7dkK3Gmf1ANubsgK4vVsifnVqNqDdcFuC97i9VucyUtE
''

$ near view sakanosita.testnet get_num --accountId sakanosita.
View call: sakanosita.testnet.get_num()
6

Solidity 入門: Merkle Proof（マークルツリーと Keccak256）

Mon, 18 Apr 2022 08:00:00 GMT

このページはこんな人におすすめ

Solidity を学びたい
マークルツリーについて知りたい
Keccak256 ハッシュ関数ってなに？

Solidity by Example のサンプルコードを使ってスマートコントラクトを作る方法を解説します。

Merkle Tree (Solidity by Example)

以下のページでほかのサンプルコードも解説しています。

Hardhat を使ったことがない方は以下の記事も合わせてご覧ください。

Hardhat の使い方: 初心者向けのスマートコントラクト開発

新しいプロジェクトを作る

merkle-tree というディレクトリを作り npm パッケージの hardhat をインストールします。

mkdir merkle-tree
cd merkle-tree
npm init -y
npm i --save-dev hardhat

Hardhat のサンプルプロジェクトを作ります。

npx hardhat

Create a sample projectを選択して、すべて Yes で回答します。

? What do you want to do? …
❯ Create a sample project
  Create an empty hardhat.config.js
  Quit

これで hardhat.config.js の初期設定や ether.js などプラグインを追加した状態になります。

コーディング

contracts/MerkleTree.sol と hardhat.config.js を編集します。 2 つの Solidity バージョンが一致するようにしましょう。

contracts/MerkleTree.sol

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

contract MerkleProof {
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf,
        uint256 index
    ) public pure returns (bool) {
        bytes32 hash = leaf;

        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];

            if (index % 2 == 0) {
                hash = keccak256(abi.encodePacked(hash, proofElement));
            } else {
                hash = keccak256(abi.encodePacked(proofElement, hash));
            }

            index = index / 2;
        }

        return hash == root;
    }
}

contract TestMerkleProof is MerkleProof {
    bytes32[] public hashes;

    constructor() {
        string[4] memory transactions = [
            "alice -> bob",
            "bob -> dave",
            "carol -> alice",
            "dave -> bob"
        ];

        for (uint256 i = 0; i < transactions.length; i++) {
            hashes.push(keccak256(abi.encodePacked(transactions[i])));
        }

        uint256 n = transactions.length;
        uint256 offset = 0;

        while (n > 0) {
            for (uint256 i = 0; i < n - 1; i += 2) {
                hashes.push(
                    keccak256(
                        abi.encodePacked(
                            hashes[offset + i],
                            hashes[offset + i + 1]
                        )
                    )
                );
            }
            offset += n;
            n = n / 2;
        }
    }

    function getRoot() public view returns (bytes32) {
        return hashes[hashes.length - 1];
    }

    /* verify
    3rd leaf
    0x1bbd78ae6188015c4a6772eb1526292b5985fc3272ead4c65002240fb9ae5d13

    root
    0x074b43252ffb4a469154df5fb7fe4ecce30953ba8b7095fe1e006185f017ad10

    index
    2

    proof
    0x948f90037b4ea787c14540d9feb1034d4a5bc251b9b5f8e57d81e4b470027af8
    0x63ac1b92046d474f84be3aa0ee04ffe5600862228c81803cce07ac40484aee43
    */
}

hardhat.config.js

require("@nomiclabs/hardhat-waffle");

/**
 * @type import('hardhat/config').HardhatUserConfig
 */
module.exports = {
  solidity: "0.8.9",
};

Keccak256 のハッシュを検証しよう

今回は、Hardhat のテスト機能で verify()関数を実行してハッシュの値を検証しながら、マークル木を理解していきましょう。 test/merkleTree.js を以下のように編集します。

test/merkleTree.js

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("MerkleProof.verify()", function () {
  it("Should return true", async function () {
    const MerkleProofFactory = await hre.ethers.getContractFactory(
      "MerkleProof"
    );
    const merkleProof = await MerkleProofFactory.deploy();
    await merkleProof.deployed();

    expect(
      await merkleProof.verify(
        [
          "0x948f90037b4ea787c14540d9feb1034d4a5bc251b9b5f8e57d81e4b470027af8",
          "0x63ac1b92046d474f84be3aa0ee04ffe5600862228c81803cce07ac40484aee43",
        ],
        "0x074b43252ffb4a469154df5fb7fe4ecce30953ba8b7095fe1e006185f017ad10",
        "0x1bbd78ae6188015c4a6772eb1526292b5985fc3272ead4c65002240fb9ae5d13",
        2
      )
    ).to.equal(true);
  });
});

以下のコマンドでテストを実行します。

npx hardhat test

（出力）
  MerkleProof.verify()
    ✓ Should return true (396ms)

  1 passing (397ms)

上のように1 passingと表示されれば、テストが期待通りであることがわかります。

Merkle Proof の解説

このプログラムでは Keccak256 とマークル木いう 2 つのアルゴリズムを使います。

Keccak256

Keccak256 はハッシュ関数です。

Keccak256 のほかによく使われるハッシュ関数は SHA-1 や MD5 などがあり、ファイル破損をチェックするときに使ったりします。

ブロックチェーンで使う Keccak256 は、スーパーコンピュータ並の計算能力を使っても任意のハッシュ値からもとの値を計算できない特徴があります。

マークル木

マークル木はデータ構造を表しています。

根(root)が上、葉(leaf)が下にあるので、実際の木とは上下が反対です。

verify()関数

このページで作る MerkleProof コントラクトの verify() 関数の目的は、keccak256 によって leaf と proof から計算した root のハッシュ値が引数と一致することです。一致すれば true 一致しなければ false を返します。

verify()関数には、4 つの引数を渡します。

bytes32[] memory proof,
bytes32 root,
bytes32 leaf,
uint256 index

先頭の proof は配列なので、可変個の値を渡すことができます。

テストコードではそれぞれ以下の値を渡します。上図のマークル木は leaf が 4 つあり、その中の node3 という leaf をここで使います。

proof:
- [“0x948f…”, “0x63ac…“]
root:
- “0x074b…”
leaf:
- “0x1bbd…”
index:
- 2

index は leaf が左から何番目かを表します。一番左の node1 は 0 なので、node3 は 2 です。

	index
node1	0
node2	1
node3	2

ハッシュ関数の計算のもとになる値

今回は 2 つのハッシュ値をつなげて新しいハッシュ値を計算しています。以下の流れで 2 回のハッシュ計算を行うと、root を計算できます。

node3 と node4 をつなげて node6 を計算する
node5 と node6 をつなげて root を計算する

引数で渡した proof[0]が node4、proof[1]が node5 です。

2 つのハッシュ値をつなげるときに、index が奇数が偶数かによって左右が決まります。

            if (index % 2 == 0) {

式を眺めたり頭で考えてもよくわかりませんが、8 つぐらいの Leaf を使って実際に計算してみてください。 Leaf の index を 2 で割りながら root に向かっていくとうまくいくことがわかります。

index	1 回目の剰余	2 回目の剰余	3 回目の剰余
0	0	0	0
1	1	0	0
2	0	1	0
3	1	1	0
4	0	0	1
5	1	0	1
6	0	1	1
7	1	1	1

2 回目以降は、前回の商を 2 で割った余りが奇数か偶数かを判断します。剰余が 0 のときは、leaf を左に、1 のときは leaf を右につなげます。

Keccak256 Online

Keccak256 のハッシュはブラウザで計算することができるので実際にコピペしてみると、Solidity で計算した Keccak256 と一致することがわかります。

https://emn178.github.io/online-tools/keccak_256.html

ハッシュ値の先頭の 0x は 16 進数を表すプレフィクスなので値を計算するときには外します。

1. “1bbd…” と　“948f…” をつなげて node6 のハッシュ”90ed…”を計算

2. “63ac…”と 1 で計算した”90ed…”をつなげて root のハッシュを計算

node5 と node6 から計算した”074b…”が root のハッシュ値です。

Solidity の keccak256() とKeccak256 Online で計算したハッシュ値が一致していることを確認できました。

このページで実際に使ったソースコードはGitHubからダウンロードできます。

Solidity 入門: オラクルの基本的な使い方（Chainlink Data Feeds)

Sun, 27 Feb 2022 21:00:00 GMT

このページはこんな人におすすめ

イーサリアム上で価格情報を使いたい
スマートコントラクトのオラクルについて知りたい
Chainlink の Ethereum Data Feed を使いたい

Solidity by Example のサンプルコードを使ってスマートコントラクトを作る方法を解説します。

Price Oracle (Solidity by Example)

このページで実際に使ったソースコードはGitHubからダウンロードできます。

オラクルと Chainlink について

オラクルは、オンチェーンのスマートコントラクトがオフチェーンの情報を利用するときに使います。

一般的な Web サービスの場合、API を呼び出しますが、EVM のスマートコントラクトは、ダイレクトにオフチェーンの API を実行することはできません。

そこで Chainlink では以下のようなしくみで、オフチェーンのデータをオンチェーンで使えるようにしています。

イーサリアム入門: オラクルのしくみ

上図の Consumer がこのページで作るスマートコントラクトです。

Proxy や Aggregator は Chainlink がデプロイしたスマートコントラクトです。

Consumer は Proxy の latestRoundData() という関数を実行して、Aggregator コントラクトが保持している state を参照します。

新しいプロジェクトを作る

price-oracle というディレクトリを作り npm パッケージの hardhat をインストールします。

mkdir price-oracle
cd price-oracle
npm init -y
npm i --save-dev hardhat

Hardhat のサンプルプロジェクトを作ります。

npx hardhat

Create a sample projectを選択して、すべて Yes で回答します。

? What do you want to do? …
❯ Create a sample project
  Create an empty hardhat.config.js
  Quit

これで hardhat.config.js の初期設定や ether.js などプラグインを追加した状態になります。

コーディング

以下のファイルを作ります。

contracts/ChainlinkPriceFeed.sol

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

// import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract ChainlinkPriceOracle {
    AggregatorV3Interface internal priceFeed;

    constructor() {
        // ETH / USD
        priceFeed = AggregatorV3Interface(
            0x8A753747A1Fa494EC906cE90E9f37563A8AF630e
        );
    }

    function getLatestPrice() public view returns (int256) {
        (
            uint80 roundID,
            int256 price,
            uint256 startedAt,
            uint256 timeStamp,
            uint80 answeredInRound
        ) = priceFeed.latestRoundData();
        // for ETH / USD price is scaled up by 10 ** 8
        return price / 1e8;
    }
}

interface AggregatorV3Interface {
    function latestRoundData()
        external
        view
        returns (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        );
}

Solidity by Example のコードをベースに PriceFeed のコントラクトアドレスを Rinkeby のアドレスに置換しています。

Ethereum Data Feed

Rinkeby Testnet (ETH / USD)

0x8A753747A1Fa494EC906cE90E9f37563A8AF630e

デプロイ (Rinkeby テストネット)

必要なもの

Rinkeby のアカウント（秘密鍵）
Rinkeby の RPC エンドポイント（Alchemy を利用）
Rinkeby の ETH 少量

Hardhat でデプロイする方法の詳細はこちらに書かれています。参照先はテストネットが Ropsten になっているので、Rinkeby に読み替えてください。

環境変数

以下の環境変数を設定します。デプロイのコマンドを実行するターミナルで実行するかログインシェル用の設定ファイルに追加してください。

RINKEBY_PRIVATE_KEY=<Rinkebyのアカウント秘密鍵>
RINKEBY_RPC_URL=<RinkebyのRPCエンドポイント>
export RINKEBY_PRIVATE_KEY RINKEBY_RPC_URL

hardhat.config.js

Hardhat の設定ファイルを作ります。

require("@nomiclabs/hardhat-waffle");

const RINKEBY_PRIVATE_KEY = process.env.RINKEBY_PRIVATE_KEY;
const RINKEBY_RPC_URL = process.env.RINKEBY_RPC_URL;

/**
 * @type import('hardhat/config').HardhatUserConfig
 */
module.exports = {
  solidity: "0.8.10",
  networks: {
    rinkeby: {
      url: `${RINKEBY_RPC_URL}`,
      accounts: [`${RINKEBY_PRIVATE_KEY}`],
    },
  },
};

scripts/deploy.js

デプロイスクリプトを用意します。

const hre = require("hardhat");

async function main() {
  const Factory = await hre.ethers.getContractFactory("ChainlinkPriceOracle");
  const contract = await Factory.deploy();
  await contract.deployed();

  console.log("Contract deployed to:", contract.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

以下のコマンドを実行してコンパイルします。

npx hardhat compile

以下のコマンドを実行して、rinkeby テストネットにデプロイします。

npx hardhat run scripts/deploy.js --network rinkeby

出力
Contract deployed to: 0xc701F8eaeF74f3DE1FEe8613855884d02CfE9517

デプロイが成功すると上記のようにコントラクトアドレスが表示されます。

実行

Rinkeby の Etherscan を使って getLatestPrice 関数を実行してみましょう。

Rinkeby の Etherscan を開く
- https://rinkeby.etherscan.io
自分がデプロイしたコントラクトアドレスを検索する
Contract タブの Read Contract をクリック
getLatestPrice 関数をクリック

現在の Chainlink の PriceFeed コントラクト(ETH/USD)から取得した値が表示されます。

もし、自分のコントラクトがうまくいかない場合は、筆者がデプロイしたコントラクトで試してみましょう。 https://rinkeby.etherscan.io/address/0xc701F8eaeF74f3DE1FEe8613855884d02CfE9517

解説

デプロイしたコントラクトの中では Chainlink の PriceFeed のコントラクトを実行しています。そのコントラクトは同じネットワーク(Rinkeby)上にデプロイされたコントラクトです。

https://rinkeby.etherscan.io/address/0x8A753747A1Fa494EC906cE90E9f37563A8AF630e

PriceFeed コントラクトの latestRoundData()は手動でも実行できます。

この関数の戻り値の中の 2 番目の answer が ETH/USD の価格を表しています。

ただし、以下の 2 つの結果は単位が違います。

PriceFeed コントラクトの latestRoundData(): 321770736905
自分が作ったコントラクトの getLatestPrice(): 3217

今回デプロイしたコードは以下のようになっています。

        ) = priceFeed.latestRoundData();
        // for ETH / USD price is scaled up by 10 ** 8
        return price / 1e8;

PriceFeed コントラクトの結果を 10 の 8 乗で除しています。 getLatestPrice()の戻り値は、int256 型なので小数点以下は切り捨てられます。

321,770,736,905 / 100,000,000 = 3,217(int256)

DFINITY ROADMAP

Sat, 29 Jan 2022 23:38:00 GMT

Internet Computer Roadmap

IC Roadmap Milestones for 2022 (Sneak Preview)

Chromium (end of Q1)

ICOS Boundary Nodes
- Long Term R&D: Boundary Nodes (proposal)
Threshold ECDSA signatures: System Integration
Threshold ECDSA signatures
- Threshold ECDSA Signatures
Nodes Can be Reassigned to a Different Subnet
Decentralized Node Addition
Enable HTTP Requests from Canisters
- Enable canisters to make HTTP(S) requests
- Long Term R&D: General Integration (Proposal)
Network Performance with Larger Network: State Sync, Certification, and XNet
Bitcoin Integration to Enable Bitcoin Smart Contracts
Open Governance for Internet Services
Custom Subdomains
Deterministic Time Slicing
Community Fund

Titanium (mid Q1 2022)

Titanium Example Dapps
Bitcoin Integration Developer Preview
- Direct Integration with Bitcoin
Merge Neurons
Simple APIs for Ledger Transactions
Ledger Canister Fit for Dapps
People Parties for Validating Personhood
Verify Candid and Motoko Stable Variable Type Safety of Canister
Enable Canisters to Hold ICPs
- Enable Canisters to Hold ICP
NNS Managed Node Provider Remuneration

Medium

Roadmap

In-site Pages

Solana Program Library: SPL Token

Sat, 22 Jan 2022 21:00:00 GMT

SPL Token Tutorial

https://spl.solana.com/token

このページの作業に必要なもの

solana-keygen コマンド
spl-token コマンド
Devnet のアカウント 2 つ
Phantom ウォレット

Solana 開発のための環境構築

独自トークンの作成

はじめに Devnet 用の SOL トークンを入手します。

solana airdrop 1

Alice の keypair を設定しているので、Alice のアドレスに 1SOL 届きます。

Alice アカウントで Fungible Token を作ります。

spl-token create-token

Creating token 35ax2anmDCqjMYRiPNRLMW6WYMCYFosr378XLNu4V1eD

Signature: 5ZovHirScb1uSAi5p7PsiDp24gmXga2ATAVrVkXbtHXHzhFYUEVCU6pbegUY5F5Z1t2uuzacB5fZZcLnBRjKJfCf

現在のトークン供給量を表示させてみます。

% spl-token supply 35ax2anmDCqjMYRiPNRLMW6WYMCYFosr378XLNu4V1eD
0

初期値は 0 です。

トークンアカウントを作ります。Solana ではトークンごとにアカウントを作る必要があります。

 % spl-token create-account 35ax2anmDCqjMYRiPNRLMW6WYMCYFosr378XLNu4V1eD
Creating account EfK3cT3Yp6xbTED5PLHa9hHsLXeSMXxuK6X3poP4gGc4

Signature: 4nJXjot5JnuPf1MjPtfsSGmKQPR5Tm34ZXxunsKUyfpwqwKKcn7HoGUJa4qhErvZT39DC4oBfnEXXV7eLu4AdvEC

100 トークンを mint します。つまり生成します。

 % spl-token mint  35ax2anmDCqjMYRiPNRLMW6WYMCYFosr378XLNu4V1eD 100
Minting 100 tokens
  Token: 35ax2anmDCqjMYRiPNRLMW6WYMCYFosr378XLNu4V1eD
  Recipient: EfK3cT3Yp6xbTED5PLHa9hHsLXeSMXxuK6X3poP4gGc4

Signature: 4V5zgPht8E6BpQGdCA9JjsAFpxKhZwdE5NifFTCghksr9AaHYADFvmR9GARWj5LKZL3Ktxk5QpAYcCGvfULzL6UM

Phantom ウォレットを使って 100 トークンのうち、20 を Bob に送ってみましょう。

supply, balance, acounts サブコマンドでトークンの Address を表示すると現在の状態がわかります。

subgraphs % spl-token supply 35ax2anmDCqjMYRiPNRLMW6WYMCYFosr378XLNu4V1eD
100

subgraphs % spl-token balance 35ax2anmDCqjMYRiPNRLMW6WYMCYFosr378XLNu4V1eD
80

subgraphs % spl-token accounts
Token                                         Balance
---------------------------------------------------------------
35ax2anmDCqjMYRiPNRLMW6WYMCYFosr378XLNu4V1eD  80

Devnet Explorer

Explorer でトークンのアドレスを入力して、バランスを見てみましょう。 2 つのアカウントが 80 対 20 になっているはずです。

https://explorer.solana.com/

NFT (Non Fungible Token)の発行

Solana では spl-token コマンドで NFT を作ることができます。

NFT といってもアートや画像を表示するものではなく、代替不可能なトークンという本来の意味のトークンです。

まず、小数点以下の桁数を 0 のトークンを作ります。

% spl-token create-token --decimals 0
Creating token FoGRhV7Lh3anC64NSjgV4XSQd5CfXhAihEWG6Diz3EbP

Signature: 3Byg1HmyM7xj47iEcmfB2PnrDDB15oimg7azG8igaZbGnQNeSTC3tC8t74bE5TqjKLQFk7snXSyzHnqNznjwwp3j

つぎにトークンアカウントを作ります。

% spl-token create-account FoGRhV7Lh3anC64NSjgV4XSQd5CfXhAihEWG6Diz3EbP
Creating account HBL76s564iGVk2TMPrSEQJWpyjdZxER7QpmSbdM2GUBk

Signature: 3x6eTSb1Fi4vL5TfYMexWN6Vzzeo1h5J9cghZLAFKLAUNKFTNTXz2vMTDcLSbJt2SMsknchppXiPfnYb9waNLnnN

トークンを 1 単位だけ mint します。

 % spl-token mint FoGRhV7Lh3anC64NSjgV4XSQd5CfXhAihEWG6Diz3EbP 1
Minting 1 tokens
  Token: FoGRhV7Lh3anC64NSjgV4XSQd5CfXhAihEWG6Diz3EbP
  Recipient: HBL76s564iGVk2TMPrSEQJWpyjdZxER7QpmSbdM2GUBk

Signature: 23LTonVsL8ntNyXasENeit2V3eZ61Gnta6gvAJSaeSKQ5LrSdTM9v4iqcEY8T4PyWttbs88CiNazyf3he8UQ5LrC

通常のトークンは、1 だけ発行しても、0.1 や 0.2 を送ることができますが、このトークンは decimals が 0 なので送信できるのは 1 単位です。

つぎに、このトークンアドレスでこれ以上トークンを mint できないようにします。

% spl-token authorize FoGRhV7Lh3anC64NSjgV4XSQd5CfXhAihEWG6Diz3EbP mint --disable
Updating FoGRhV7Lh3anC64NSjgV4XSQd5CfXhAihEWG6Diz3EbP
  Current mint authority: 6MJgewZBJyzJseZnwWZX11RUwydLVYoVJevJDCHenKaY
  New mint authority: disabled

Signature: FZv8x2MNEjvcphb2jb3B4zYGeP8PGpmAvWey9NXE7j5HkqkiB9AXjgFZi5TCbZoirdQCYNnmbyqdd5mFouGcypN

このトークンは 1 つしかなく、新たに mint して増やすこともできないので、Non-fungible です。

Solana 開発のための環境構築

Sat, 22 Jan 2022 20:00:00 GMT

CLI のインストール

以下のようなコマンドをインストールします。

solana
solana-keygen
spl-token

Solana Tool Suite

https://docs.solana.com/cli/install-solana-cli-tools

SPL Token CLI

https://spl.solana.com/token

テスト用のキーペアを用意する

Solana Docmentation - Keypair conventions

検証用にアカウントを用意します。目的に応じて 2 つまたは 3 つあると便利です。

わかりやすいように、キーペアに好きな名前をつけます。例：Alice, Bob, Carol など

以下のコマンドを入力すると新しいキーペアを作ることができます。

solana-keygen new

solana-keygen を実行するときにリカバリフレーズが表示されます。

Save this seed phrase and your BIP39 passphrase to recover your new keypair:
xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx

検証用のアカウントとして使い捨てるなら不要ですが、あとで復旧することがあるなら保管しましょう。

新しいキーペアはホームディレクトリ配下に id.json という名前でファイルが作成されます。それぞれファイル名を変更します。

solana-keygen new
mv ~/.config/solana/id.json ~/.config/solana/alice.json

solana-keygen new
mv ~/.config/solana/id.json ~/.config/solana/bob.json

solana-keygen new
mv ~/.config/solana/id.json ~/.config/solana/carol.json

Phantom ウォレットのインポート

3 つのアカウントを Phantom ウォレットにインポートします。

pbcopy コマンドを使うとファイルの中身をクリップボードにコピーできるので、ウォレットのインポート画面でペーストすればインポートできます。

pbcopy < ~/.config/solana/alice.json
pbcopy < ~/.config/solana/bob.json
pbcopy < ~/.config/solana/carol.json

Config 設定

API (Devnet)

solana config set --url https://api.devnet.solana.com

Alice/Bob/Carol の Key を設定

solana config set --keypair ${HOME}/.config/solana/alice.json
solana config set --keypair ${HOME}/.config/solana/bob.json
solana config set --keypair ${HOME}/.config/solana/carol.json

SOL を入手

Config 設定で Devnet と Alice が設定されていれば、Devnet の Alice のウォレットに 1SOL 入ります。

solana airdrop 1

web3.js を使ってスマートコントラクトを実行する3つの方法【Solidity 入門】

Sat, 22 Jan 2022 10:38:00 GMT

このページはこんな人におすすめ

自分で作ったスマートコントラクトを実行したい
JavaScript からスマコンを実行する方法がわからない
Node.js のモジュールを使ってシンプルにスマコンを実行したい
web3.js の使い方がわからない

このページでは、ブロックチェーン上にデプロイしたスマートコントラクトを web3.js を使って実行する方法を３つ紹介します。

HTML と JavaScript だけのシンプルな web3.js
Next.js を使った web3.js（Chrome のコンソールに表示）
Next.js を使った web3.js（HTML に表示）

今回実行するスマートコントラクトは、以下の記事で作った Hello World プログラムです。

必要なもの

live-server
Next.js アプリケーション
npm の web3.js
スマートコントラクトのアドレス
スマートコントラクトの ABI

live-server

３つの確認方法のうち、

HTML と JavaScript ファイルだけの web3.js の実行方法 1 番目では live-server を使います。live-server は npm を使ってインストールできます。 live-server はローカル PC 上で利用できる軽量な HTTP サーバです。 PC 上の HTML ファイルをブラウザを通してアクセスできます。

Next.js アプリケーション

JavaScript を使ったアプリケーションを書く場合、React や Vue.js などいろんなフレームワークを使いますが、それらは基本的にサーバサイドの JavaScript 言語である Node.js を使っています。

Node.js を使ってスマートコントラクトを実行する方法は、いろいろあります。なるべくシンプルで汎用的に応用できることを考えて Next.js を使った 2 つ web3.js の実行方法を紹介します。

Next.js の新しいプロジェクトを用意してください。

https://nextjs.org/docs/getting-started

npm の web3.js

Next.js のプロジェクトに npm を使って web3.js をインストールします。

プロジェクトのトップディレクトリ（package.json ファイルのある場所）で以下のコマンドを実行しましょう。

npm install web3 --save

スマートコントラクトのアドレス

スマートコントラクトを実行する場合にコントラクトアドレスを指定します。今回使うスマートコントラクトのアドレスを調べましょう。

Truffle を使って Ganache にコントラクトをデプロイした場合は、build ディレクトリの下に helloWorld.json というファイルが作られて、中にコントラクトアドレスがかかれています。

  "networks": {
    "5777": {
      "events": {},
      "links": {},
      "address": "0x0cb51E4BF025C8F5Df16B3f523249C58e1361B73",
      "transactionHash": "0xbd6c7a8de462e0c35b5c696aab5b02a64775aa7a6c3a4545ce0820d1457bd920"
    }
  },

スマートコントラクトの ABI

スマートコントラクトを実行する場合、そのコントラクトがどんなファンクションを持っているのかやどんな型の情報を返すのかといったインターフェースの情報が必要になります。それが ABI（Application Binary Interface）です。

Truffle でデプロイした場合は、コントラクトアドレスと同じく build ディレクトリ配下の helloWorld.json に書かれています。

  "abi": [
    {
      "constant": true,
      "inputs": [],
      "name": "get",
      "outputs": [
        {
          "internalType": "string",
          "name": "",
          "type": "string"
        }
      ],
      "payable": false,
      "stateMutability": "pure",
      "type": "function"
    }
  ],

HTML と JavaScript だけのシンプルな web3.js

コード

３つのファイルを作って同じディレクトリに置きましょう。

index.html
app.js
helloWorld.js

index.html

<!DOCTYPE html>
<html lang="ja">
  <head>
    <title>Ðapps - Hello World</title>
    <script src="https://cdn.jsdelivr.net/npm/web3@latest/dist/web3.min.js"></script>
    <script type="module" src="app.js"></script>
  </head>
  <body>
    <div id="contract-result">loading...</div>
  </body>
</html>

app.js

import helloWorld from "./helloWorld.js";

window.onload = function () {
  helloWorld();
};

helloWorld.js

export default function () {
  var abi = [
    {
      constant: true,
      inputs: [],
      name: "get",
      outputs: [
        {
          name: "",
          type: "string",
        },
      ],
      payable: false,
      stateMutability: "pure",
      type: "function",
    },
  ];

  var address = "0x5B0A7974Aeab510BB344e7f27e607841b4EC4C9f"; // コントラクトアドレス

  const web3 = new Web3(Web3.givenProvider || "ws://localhost:7545");

  var contract = new web3.eth.Contract(abi, address);
  contract.methods.get().call(function (err, res) {
    document.getElementById("contract-result").textContent = res;
    console.log(res);
  });
}

確認手順

配置したディレクトリで live-server を実行します。

live-server .

live-server を実行すると、自動でブラウザが開いて index.html を表示します。

解説

HTML と JavaScript を使った一番シンプルなやり方です。

ここではインターネット上の web3.js を CDN からダウンロードして使っています。あとから紹介する Next.js を使う 2 つのやり方では、Node.js ライブラリの web3.js を使います。

<script src="https://cdn.jsdelivr.net/npm/web3@latest/dist/web3.min.js"></script>

どのブロックチェーンに繋ぐかどうかは、helloWorld.js の以下の行で指定しています。

const web3 = new Web3(Web3.givenProvider || "ws://localhost:7545");

ブラウザに Metamask などがある場合は、Web3.givenProvider を指定すると Metamask が接続しているブロックチェーンのエンドポイントをもとに web3 オブジェクトが作られます。

Web3.givenProvider で取得できない場合は、”ws://localhost:7545″に接続するように書いています。これは Ganache に接続するときの WebSocket のエンドポイントです。

Next.js を使った web3.js（Chrome のコンソールに表示）

コード

Next.js アプリケーションの pages ディレクトリの下に hello1.js というファイルを作って、以下のコードを貼り付けます。

コントラクトアドレスや ABI は自分の使うコントラクトに置き換えましょう。

pages/hello1.js

import Web3 from "web3";

var abi = [
  {
    constant: true,
    inputs: [],
    name: "get",
    outputs: [
      {
        name: "",
        type: "string",
      },
    ],
    payable: false,
    stateMutability: "pure",
    type: "function",
  },
];

var address = "0x5B0A7974Aeab510BB344e7f27e607841b4EC4C9f"; // コントラクトアドレス

function Hello1() {
  var ret = "";
  const web3 = new Web3(Web3.givenProvider || "ws://localhost:7545");

  var contract = new web3.eth.Contract(abi, address);
  contract.methods.get().call(function (err, res) {
    console.log(res);
    ret = res;
  });

  return "ret: " + ret;
}

export default Hello1;

確認手順

Next.js のドキュメントに従って Next.js を起動します。インストール方法によって起動コマンドは変わります。

yarn dev

Chrome ブラウザから以下の URL にアクセスします。

http://localhost:3000/hello1

Chrome の Developer Tools のコンソールタブを開きます。Mac なら「command」＋「option」+「I（アイ）｝で開きます。

Console に”Hello World!”という文字が表示されています。これはスマートコントラクトから取得した文字列です。

ブラウザで表示する HTML は下のようになると思います。HTML では”Hello World”を表示できていない状態です。

HTML に表示させるやり方は 3 番目で紹介します。

解説

先ほどの 1 つ目の HTML を使った実行方法では、web3.js は CDN からダウンロードしてブラウザ上で JavaScript を実行しました。

今回は、web3.js は Node.js のモジュールを使っています。

一般的なアプリケーション開発では、Node.js を使ったやり方が主流になると思います。React や Vue を使う場合も Node.js の web3.js を使います。

ブロックチェーンとの接続部分や web3 オブジェクトの使い方は 1 つ目の HTML の方法と基本的に同じです。

取得した Hello World という文字列を返して、HTML に表示させようとしていますが、じつはこれはうまく動きません。

return "ret: " + ret;

つぎの 3 番目の方法では、Next.js で API やスマートコントラクトなど外部から取得したデータを HTML に表示するやり方で紹介します。

Next.js を使った web3.js（HTML に表示）

コード

Next.js アプリケーションの pages ディレクトリの下に hello2.js というファイルを作って、以下のコードを貼り付けます。

コントラクトアドレスや ABI は自分の使うコントラクトに置き換えましょう。

pages/hello2.js

import Web3 from "web3";

function Hello2({ message }) {
  console.log("message: " + message);
  return <ul>{message}</ul>;
}

export async function getStaticProps() {
  let message = "hoge22";
  let abi = [
    {
      constant: true,
      inputs: [],
      name: "get",
      outputs: [
        {
          name: "",
          type: "string",
        },
      ],
      payable: false,
      stateMutability: "pure",
      type: "function",
    },
  ];

  let address = "0x5B0A7974Aeab510BB344e7f27e607841b4EC4C9f";

  const web3 = new Web3(Web3.givenProvider || "ws://localhost:7545");
  const contract = new web3.eth.Contract(abi, address);

  await contract.methods.get().call(function (err, res) {
    message = res;
  });

  return {
    props: {
      message,
    },
  };
}

export default Hello2;

確認手順

Next.js のドキュメントに従って Next.js を起動します。インストール方法によって起動コマンドは変わります。

yarn dev

Chrome ブラウザから以下の URL にアクセスします。

http://localhost:3000/hello2

今度は HTML に”Hello World!”を表示できるはずです。

解説

2 番目と 3 番目の違いは、スマートコントラクトのように外部から取得するデータを Console に表示しているか、HTML に表示しているかの違いです。

実際のアプリケーション開発に近いのはこの 3 番目のやり方ではないでしょうか。

しかし、このやり方はうまく動かないときに、何が原因でうごかないのか見分けにくいというデメリットがあります。

JavaScritpt の非同期による問題
Next.js の記述方法の問題
スマートコントラクトの実行方法の問題

そういう時に、1 番目や 2 番目のやり方を合わせて使うことで、どこがうまく動いて、どこが動いていないのかを見分けることができます。

Solidity 入門: 定義したイベントを発行してブロックチェーンに記録

Fri, 21 Jan 2022 19:00:00 GMT

このページはこんな人におすすめ

Solidity を学びたい
簡単なスマートコントラクトの作り方を知りたい
EVM の Event のことを知りたい

Solidity by Example のサンプルコードを使ってスマートコントラクトを作る方法を解説します。

以下のページでほかのサンプルコードも解説しています。

Hardhat を使ったことがない方は以下の記事も合わせてご覧ください。

Hardhat の使い方: 初心者向けのスマートコントラクト開発

新しいプロジェクトを作る

events というディレクトリを作り npm パッケージの hardhat をインストールします。

mkdir events
cd events
npm init -y
npm i --save-dev hardhat

Hardhat のサンプルプロジェクトを作ります。

npx hardhat

Create a sample projectを選択して、すべて Yes で回答します。

? What do you want to do? …
❯ Create a sample project
  Create an empty hardhat.config.js
  Quit

これで hardhat.config.js の初期設定や ether.js などプラグインを追加した状態になります。

コーディング

以下のファイルを作ります。

contracts/Events.sol

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

contract Event {
    // Event declaration
    // Up to 3 parameters can be indexed.
    // Indexed parameters helps you filter the logs by the indexed parameter
    event Log(address indexed sender, string message);
    event AnotherLog();

    function test() public {
        emit Log(msg.sender, "Hello World!");
        emit Log(msg.sender, "Hello EVM!");
        emit AnotherLog();
    }
}

Log()と AnotherLog()という 2 つのイベントを定義して、test()関数を実行したときにそのイベントを発行しています。ブロックチェーンにイベントを記録するときには、emit を付けます。

イベントにはパラメータを渡すことができ、3 つまで indexed することができます。 indexed をつけたパラメータでログをフィルタリングすることができます。

今回は Rinkeby というテストネットにデプロイするので、デプロイ用の設定も書いています。

hardhat.config.js

require("@nomiclabs/hardhat-waffle");

// This is a sample Hardhat task. To learn how to create your own go to
// https://hardhat.org/guides/create-task.html
task("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
  const accounts = await hre.ethers.getSigners();

  for (const account of accounts) {
    console.log(account.address);
  }
});

const RINKEBY_PRIVATE_KEY = process.env.RINKEBY_PRIVATE_KEY;
const RINKEBY_RPC_URL = process.env.RINKEBY_RPC_URL;

/**
 * @type import('hardhat/config').HardhatUserConfig
 */
module.exports = {
  solidity: "0.8.9",
  networks: {
    rinkeby: {
      url: `${RINKEBY_RPC_URL}`,
      accounts: [`${RINKEBY_PRIVATE_KEY}`],
    },
  },
};

デプロイ

テストネットへのデプロイには以下の 2 つの環境変数が必要です。

RINKEBY_PRIVATE_KEY
RINKEBY_RPC_URL

詳細はこちら

デプロイ用にスクリプトを用意します。

scripts/deploy.js

const hre = require("hardhat");

async function main() {
  const Factory = await hre.ethers.getContractFactory("Event");
  const contract = await Factory.deploy();
  await contract.deployed();

  console.log("Contract deployed to:", contract.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

環境変数を export した端末で以下のコマンドを実行します。

npx hardhat run scripts/deploy.js --network rinkeby

（出力）
Contract deployed to: 0xc5BeE3DDcD7F58380Aa0CA3D01dA63a34a9C3c09

このときに出力するコントラクトアドレスを書き留めてください。

イベントの発行

コントラクトをデプロイしただけでは、まだイベントを発行していません。イベントを発行するためには、test()関数を実行する必要があります。スマートコントラクトの実行方法はいろいろありますが、ここでは Etherscan を使ってみましょう。

Function の実行準備

Rinkeby の Explorer(Etherscan)を開き、デプロイしたコントラクトアドレスを検索しましょう。デプロイの直後はすぐに表示されないかもしれません。2, 3 分待てば表示されます。

作ったコントラクトの Function を Etherscan で実行するためにソースコードの「Verify and Publish」を行ってください。この作業は慣れれば 1 分で終わります。

コントラクトを Etherscan で最適化しよう。

Function の実行

関数の実行には Rinkeby の ETH が少量必要です。テストネットの ETH は無料で入手できます。

Rinkeby の Etherscan を開いて自分のコントラクトを検索します。

https://rinkeby.etherscan.io/address/0xc5bee3ddcd7f58380aa0ca3d01da63a34a9c3c09#writeContract

[Contract]タブの[Write Contract]を表示
[Connect to Web3]をクリックすると Metamask を接続
[test]の[Write]をクリックして test()関数を実行

Event の確認

test()を実行したらトランザクションが完了するまで待ちましょう。トランザクションが Success になったら Events タブを開くと、イベントのログを見ることができます。

このページで実際に使ったソースコードを GitHub からダウンロードできます。

Introducing Rust free learning sites

Tue, 04 Jan 2022 19:38:00 GMT

Learn Rust

https://www.rust-lang.org/learn

Introduction to Rust

https://serokell.io/blog/rust-guide

Tour of Rust

https://tourofrust.com/

Rust by Example

https://doc.rust-lang.org/rust-by-example/index.html

rustlings

https://github.com/rust-lang/rustlings/

exercism

https://exercism.org/tracks/rust

A half-hour to learn Rust

https://fasterthanli.me/articles/a-half-hour-to-learn-rust

Thank you for your nice tweet, @ocrybit

Motoko プログラミング入門: CYCLE ウォレットとキャニスター

Mon, 03 Jan 2022 20:38:00 GMT

このページは、DFINITY のチュートリアルを日本語で解説しています。

Accept cycles from a wallet

実際に使ったソースコードはGitHubからダウンロードできます。

実行環境

dfx: 0.8.4
macOS: 11.5.2
npm version: 8.1.3
任意のターミナル
任意のテキストエディタ

dfx について知りたい方はこちらをどうぞ

5 ステップではじめる Motoko プログラミング入門

ターミナルは、なんでもよいので Mac 標準のターミナルで大丈夫です。テキストエディタは Visual Studio Code を筆者は使っています。

手順

プロジェクトの作成

新しいプロジェクトを作ります。

dfx new cycles_hello
cd cycles_hello

コーディング

src/cycles_hello/main.mo

import Nat64 "mo:base/Nat64";
import Cycles "mo:base/ExperimentalCycles";

shared(msg) actor class HelloCycles (
   capacity: Nat
  ) {

  var balance = 0;

  // Return the current cycle balance
  public shared(msg) func wallet_balance() : async Nat {
    return balance;
  };

  // Return the cycles received up to the capacity allowed
  public func wallet_receive() : async { accepted: Nat64 } {
    let amount = Cycles.available();
    let limit : Nat = capacity - balance;
    let accepted =
      if (amount <= limit) amount
      else limit;
    let deposit = Cycles.accept(accepted);
    assert (deposit == accepted);
    balance += accepted;
    { accepted = Nat64.fromNat(accepted) };
  };

  // Return the greeting
  public func greet(name : Text) : async Text {
    return "Hello, " # name # "!";
  };

  // Return the principal of the caller/user identity
  public shared(msg) func owner() : async Principal {
    let currentOwner = msg.caller;
    return currentOwner;
  };

};

起動＆デプロイ

ローカル実行環境を起動

dfx start --clean --background

キャニスターのビルド＆デプロイ

dfx deploy --argument '(360000000000)'

出力
cycles_hello % dfx deploy --argument '(360000000000)'
Creating a wallet canister on the local network.
The wallet canister on the "local" network for user "default" is "rwlgt-iiaaa-aaaaa-aaaaa-cai"
Deploying all canisters.
Creating canisters...
Creating canister "cycles_hello"...
"cycles_hello" canister created with canister id: "rrkah-fqaaa-aaaaa-aaaaq-cai"
Creating canister "cycles_hello_assets"...
"cycles_hello_assets" canister created with canister id: "ryjl3-tyaaa-aaaaa-aaaba-cai"
Building canisters...
（中略）
Committing batch.
Deployed canisters.

キャニスターの owner の Principal ID を表示させます

dfx canister call cycles_hello owner

出力
(principal "zr2yi-7hrww-jgne7-j4gbs-2xu5a-ms3wg-ixp3t-4azyp-ifmeb-yxym6-sqe")

この Principal ID はデプロイした Identity の Principal ID で以下のコマンドの結果と一致します。

dfx identity get-principal

動作確認

CYCLES の確認

CYCLE は Wallet キャニスターが管理しています。このプロジェクトに登場するウォレットは 2 つあります。

dfx の実行ユーザー用のウォレット
cycles_hello キャニスター用のウォレット

cycles_hello キャニスターのウォレットの初期残高を表示

dfx canister call cycles_hello wallet_balance
(0 : nat)

dfx の実行ユーザーのウォレットから cycles_hello キャニスターのウォレットに 256,000,000,000CYCLE を移動

dfx canister call rwlgt-iiaaa-aaaaa-aaaaa-cai wallet_send '(record { canister = principal "rrkah-fqaaa-aaaaa-aaaaq-cai"; amount = (256000000000:nat64); } )'

出力
(variant { 17_724 })

cycles_hello キャニスターのウォレットの残高を表示

dfx canister call cycles_hello wallet_balance
(256_000_000_000 : nat)

dfx 実行ユーザーの wallet 残高を表示

dfx canister call rwlgt-iiaaa-aaaaa-aaaaa-cai wallet_balance

出力
(record { 3_573_748_184 = 91_744_000_000_000 : nat64 })

キャニスターを実行したらどのウォレットから CYCLE が消費されるか

dfx canister call cycles_hello greet '("from DFINITY")'
("Hello, from DFINITY!")

dfx canister call rwlgt-iiaaa-aaaaa-aaaaa-cai wallet_balance

出力
(record { 3_573_748_184 = 91_744_000_000_000 : nat64 })

DFINITY の Document では、このときに dfx 実行ユーザーの wallet の CYCLE 残高が減少してますが筆者の環境では、どちらのウォレットの CYCLE も減りませんでした。

詳しく調べて、また後日、更新したいと思います。

停止

dfx.json があるディレクトリで以下のコマンドを実行して、実行環境を停止します。

dfx stop

2023-05-14 追記

当記事の内容は古くなっている可能性があります。記事の趣旨は少し変わりますが、新しいキャニスターの記事がこちらにあります。

Cycle Wallet キャニスター図解

Motoko プログラミング入門: ID とアクセス管理

Sun, 02 Jan 2022 20:38:00 GMT

このページでは DFINITY(Internet Computer)の Motoko Language のチュートリアルを日本語で解説しています。

Add access control with identities

実際に使ったソースコードはGitHubからダウンロードできます。

はじめての方はこちらをご覧ください。

5 ステップではじめる Motoko プログラミング入門

実行環境

dfx: 0.8.4
macOS: 11.5.2
npm version: 8.1.3
任意のターミナル
任意のテキストエディタ

ターミナルとテキストエディタは好きなソフトウェアを使えば大丈夫です。

はじめは Mac 標準のターミナルでよいと思います。テキストエディタは筆者は Visual Studio Code を使っています。

本プロジェクトで学ぶこと

ユーザーごとに権限を割り当てて、処理を変える方法を実現します。いろんなユースケースで使える実用的なチュートリアルです。

dfx コマンドラインツールには identity という概念があり、複数の identity を作ったり切り替えてアクセスすることができます。

identity は、秘密鍵と Principal ID のペアです。

秘密鍵は dfx コマンドを実行するローカル側に持ちます。キャニスター側では、Principal ID で識別します。

手順

プロジェクトの作成

新しいプロジェクトを作ります。

dfx new access_hello
cd access_hello

コーディング

エディタを使って、src/access_hello/main.mo を編集します。

// Import base modules
import AssocList "mo:base/AssocList";
import Error "mo:base/Error";
import List "mo:base/List";

shared({ caller = initializer }) actor class() {

    // Establish role-based greetings to display
    public shared({ caller }) func greet(name : Text) : async Text {
        if (has_permission(caller, #assign_role)) {
            return "Hello, " # name # ". You have a role with administrative privileges."
        } else if (has_permission(caller, #lowest)) {
            return "Welcome, " # name # ". You have an authorized account. Would you like to play a game?";
        } else {
            return "Greetings, " # name # ". Nice to meet you!";
        }
    };

    // Define custom types
    public type Role = {
        #owner;
        #admin;
        #authorized;
    };

    public type Permission = {
        #assign_role;
        #lowest;
    };

    private stable var roles: AssocList.AssocList<Principal, Role> = List.nil();
    private stable var role_requests: AssocList.AssocList<Principal, Role> = List.nil();

    func principal_eq(a: Principal, b: Principal): Bool {
        return a == b;
    };

    func get_role(pal: Principal) : ?Role {
        if (pal == initializer) {
            ?#owner;
        } else {
            AssocList.find<Principal, Role>(roles, pal, principal_eq);
        }
    };

    // Determine if a principal has a role with permissions
    func has_permission(pal: Principal, perm : Permission) : Bool {
        let role = get_role(pal);
        switch (role, perm) {
            case (?#owner or ?#admin, _) true;
            case (?#authorized, #lowest) true;
            case (_, _) false;
        }
    };

    // Reject unauthorized user identities
    func require_permission(pal: Principal, perm: Permission) : async () {
        if ( has_permission(pal, perm) == false ) {
            throw Error.reject( "unauthorized" );
        }
    };

    // Assign a new role to a principal
    public shared({ caller }) func assign_role( assignee: Principal, new_role: ?Role ) : async () {
        await require_permission( caller, #assign_role );

        switch new_role {
            case (?#owner) {
                throw Error.reject( "Cannot assign anyone to be the owner" );
            };
            case (_) {};
        };
        if (assignee == initializer) {
            throw Error.reject( "Cannot assign a role to the canister owner" );
        };
        roles := AssocList.replace<Principal, Role>(roles, assignee, principal_eq, new_role).0;
        role_requests := AssocList.replace<Principal, Role>(role_requests, assignee, principal_eq, null).0;
    };

    public shared({ caller }) func request_role( role: Role ) : async Principal {
        role_requests := AssocList.replace<Principal, Role>(role_requests, caller, principal_eq, ?role).0;
        return caller;
    };

    // Return the principal of the message caller/user identity
    public shared({ caller }) func callerPrincipal() : async Principal {
        return caller;
    };

    // Return the role of the message caller/user identity
    public shared({ caller }) func my_role() : async ?Role {
        return get_role(caller);
    };

    public shared({ caller }) func my_role_request() : async ?Role {
        AssocList.find<Principal, Role>(role_requests, caller, principal_eq);
    };

    public shared({ caller }) func get_role_requests() : async List.List<(Principal,Role)> {
        await require_permission( caller, #assign_role );
        return role_requests;
    };

    public shared({ caller }) func get_roles() : async List.List<(Principal,Role)> {
        await require_permission( caller, #assign_role );
        return roles;
    };
};

デプロイ

ローカルの実行環境を起動します。

dfx start --background

--backgroundオプションをつけることで、後続のコマンドを同じウィンドウで実行できます。

dfx deploy access_hello

出力
Deploying: access_hello
Creating canisters...
Creating canister "access_hello"...
"access_hello" canister created with canister id: "rwlgt-iiaaa-aaaaa-aaaaa-cai"
Building canisters...
Installing canisters...
Installing code for canister access_hello, with canister_id rwlgt-iiaaa-aaaaa-aaaaa-cai
Deployed canisters.

実行

これから 4 つの identity を使ってキャニスターの動作を検証します。各 identity はそれぞれ別の role を割り当てます。

identity	role
default	owner
ic_admin	admin
alice_auth	authorized
bob_standard	none

キャニスターをデプロイした identity は owner

dfx が使っている現在の identity を確認

access_hello % dfx identity whoami
default

Principal ID を確認

access_hello % dfx identity get-principal
zr2yi-7hrww-jgne7-j4gbs-2xu5a-ms3wg-ixp3t-4azyp-ifmeb-yxym6-sqe

my_role 関数で実行者の Principal ID に紐づく role を表示させてみます。

dfx canister --wallet=$(dfx identity get-wallet) call access_hello my_role

出力
(opt variant { owner })

このキャニスターをデプロイしたdefaultの identity はownerロールになっています。

ic_admin

ic_adminという新しい identity を作ります。新しい秘密鍵と Principal ID のペアが作られます。

dfx identity new ic_admin

出力
Creating identity: "ic_admin".
Created identity: "ic_admin".

ic_adminを使って my_role 関数を実行してみましょう。

dfx --identity ic_admin canister call access_hello my_role

出力
(null)

さっきまでは—identity オプションで指定していましたが、 dfx の identity をic_adminに切り替えます。

access_hello % dfx identity use ic_admin && dfx identity get-principal
Using identity: "ic_admin".
ptgej-o2oox-uin5n-64lps-ouln7-e677b-jwi75-ije6c-x3awj-o6yw7-mae

切り替えた identity でaccess_helloキャニスターを call して、Principal を確認します

access_hello % dfx canister call access_hello callerPrincipal
(principal "ptgej-o2oox-uin5n-64lps-ouln7-e677b-jwi75-ije6c-x3awj-o6yw7-mae")

ic_adminの Principal ID でキャニスターを実行していることが確認できました。

ロールのアサイン

ic_adminにadminロールをアサインするために、いったんownerであるdefaultに戻しましょう

dfx identity use default

defaultの権限を使ってic_adminにadminロールをアサインします。アサインするときは、先ほど表示させたadminの Principal ID を渡します。

dfx canister --wallet=$(dfx identity get-wallet) call access_hello assign_role '((principal "ptgej-o2oox-uin5n-64lps-ouln7-e677b-jwi75-ije6c-x3awj-o6yw7-mae"),opt variant{admin})'

再びic_adminの identity で my_role を実行してみます。

dfx --identity ic_admin canister call access_hello my_role

出力
(opt variant { admin })

ic_adminで実行した my_role 関数の結果、adminになりました。

ic_adminを使って greet 関数を実行してみましょう。

dfx --identity ic_admin canister call access_hello greet "Internet Computer Admin"
(
  "Hello, Internet Computer Admin. You have a role with administrative privileges.",
)

greet 関数はロールによってメッセージが変わります。興味があれば main.mo を見てみましょう！

alice_auth に authorized ロールをアサイン

新しくalice_authという identity を作ります。

dfx identity new alice_auth

出力
Creating identity: "alice_auth".
Created identity: "alice_auth".

alice_authに切り替えます。

dfx identity use alice_auth

alice_authの Principal ID をALICE_IDという環境変数に入れます。

ALICE_ID=$(dfx identity get-principal)

ALICE_IDの中身を確認してみましょう。

echo $ALICE_ID
lwhzc-k3xsu-i222u-6guck-cszug-i6fnj-uhigp-4hjgo-2uhyv-qma73-mae

ic_adminの権限でalice_authの Principal ID にauthorizedというロールをアサインします。

dfx --identity ic_admin canister call access_hello assign_role "(principal \"$ALICE_ID\", opt variant{authorized})"

alice_authのロールを確認します。

dfx --identity alice_auth canister call access_hello my_role

出力
(opt variant { authorized })

authorizedロールがアサインされたalice_authで greet 関数を call してみましょう。

dfx canister call access_hello greet "Alice"
(
  "Welcome, Alice. You have an authorized account. Would you like to play a game?",
)

bob_standard

今使っている identity がわからなくなってしまったら、whoami で表示させたり use で切り替えたりしてください。また切り替えなくても—identity オプションで実行する identity を指定することもできるので好きに使い分けてください。

dfx identity whoami
dfx identity use <切り替え先>
dfx --identity <実行者> canister call ...

bob_standardを作ります。

dfx identity new bob_standard
Creating identity: "bob_standard".
Created identity: "bob_standard".

BOB_ID=$(dfx --identity bob_standard identity get-principal)

作ったばかりでなにも権限を持っていないbob_standardの実行によって、bob_standard にauthorizedをアサインさせようと試みます。これは失敗することを期待しています。

dfx --identity bob_standard canister call access_hello assign_role "(principal \"$BOB_ID\", opt variant{authorized})"

出力
The Replica returned an error: code 4, message: "unauthorized"

owner 権限を持つ default の identity を使って、bob_standard に owner 権限をアサインしてみましょう。

dfx --identity default canister --wallet=$(dfx --identity default identity get-wallet) call access_hello assign_role "(principal \"$BOB_ID\", opt variant{owner})"

このコマンドは以下のようにエラーを出力します。ユーザーを owner にすることはできません。

出力
An error happened during the call: 4: Cannot assign anyone to be the owner

ロールを与えられていないbob_standardで greet 関数を実行してみましょう。

dfx --identity bob_standard canister --no-wallet call access_hello greet "Bob"
("Greetings, Bob. Nice to meet you!")

このように与えられたロールによって実行できる関数と実行できない関数をできました。

停止

dfx.json があるディレクトリで以下のコマンドを実行して、実行環境を停止します。

dfx stop

Motoko プログラミング入門: キャニスター間の関数呼び出し

Thu, 30 Dec 2021 21:00:00 GMT

このページは、DFINITY の Motoko Language のチュートリアルを日本語で解説しています。

Make inter-canister calls

実際に使ったソースコードはGitHubからダウンロードできます。

はじめての方はこちらをご覧ください。

5 ステップではじめる Motoko プログラミング入門

実行環境

dfx: 0.6.22
macOS: 11.5.2
npm version: 8.1.3

dfx 0.6.22 のインストール

執筆時の dfx の最新バージョンは 0.8.4 ですが、このプログラムは 0.8.x では動作しません。 0.6.22 を指定してインストールします。チュートリアルが終わったら最新バージョンに戻しましょう。

DFX_VERSION=0.6.22 sh -ci "$(curl -fsSL https://sdk.dfinity.org/install.sh)"

手順

プロジェクトの作成

GitHub からプロジェクトを取得します。

git clone https://github.com/dfinity/linkedup.git
cd linkedup

ライブラリのインストール

npm install
npm audit fix

実行環境の起動

dfx start --background

出力
Starting webserver on port 50931 for replica at "http://localhost:50931"
binding to: V4(0.0.0.0:8000)
replica(s): http://localhost:50931/

キャニスターの登録

dfx canister create --all

出力
Creating canister "connectd"...
"connectd" canister created with canister id: "rwlgt-iiaaa-aaaaa-aaaaa-cai"
Creating canister "linkedup"...
"linkedup" canister created with canister id: "rrkah-fqaaa-aaaaa-aaaaq-cai"
Creating canister "linkedup_assets"...
"linkedup_assets" canister created with canister id: "ryjl3-tyaaa-aaaaa-aaaba-cai"

ビルド(コンパイル)

dfx build

出力
Building canisters...
Building frontend...

デプロイ（インストール）

dfx canister install --all

出力
Installing code for canister connectd, with canister_id rwlgt-iiaaa-aaaaa-aaaaa-cai
Installing code for canister linkedup, with canister_id rrkah-fqaaa-aaaaa-aaaaq-cai
Installing code for canister linkedup_assets, with canister_id ryjl3-tyaaa-aaaaa-aaaba-cai
Uploading assets to asset canister...

実行

キャニスター ID

当プロジェクトには 3 つのキャニスターを作っています。

connectd
linkedup
linkedup_assets

キャニスターをブラウザ経由で実行します。ブラウザ経由で実行する時に、各キャニスターの ID を URL で指定します。

キャニスター ID は、ビルドやデプロイ時に表示されます。もし記録していなくてものファイルを見ればわかります。

linkedup/.dfx/local/canister_ids.json

linkedup % cat .dfx/local/canister_ids.json
{
  "connectd": {
    "local": "rwlgt-iiaaa-aaaaa-aaaaa-cai"
  },
  "linkedup": {
    "local": "rrkah-fqaaa-aaaaa-aaaaq-cai"
  },
  "linkedup_assets": {
    "local": "ryjl3-tyaaa-aaaaa-aaaba-cai"
  }
}%

フロントエンドキャニスター

127.0.0.1 は自分の PC にアクセスするための IP アドレスです。

http://127.0.0.1:8000/?canisterId=<ic-identifier-for-linkedup-assets>

linkedup_assets のキャニスター ID に置き換えた URL をブラウザで開きます。

http://127.0.0.1:8000/?canisterId=ryjl3-tyaaa-aaaaa-aaaba-cai

Linkedin そっくりのサイトが表示されました笑

自分の名前や組織名を入力して保存します。

シークレットウィンドウでもう 1 つブラウザを開きます。 URL は先ほどと同じです。

シークレットウィンドウではまた新しいユーザーを作成します。ウィンドウごとにそれぞれの 2 つのユーザープロファイルを作成できました。

それぞれの Window で相手を検索したり、CONNECT をクリックしたり、自由に試してみましょう。どんな操作もだいたい 2~3 秒遅れて反応すると思います。

実行環境の停止

終わったらローカル PC 上の実行環境を停止します。

dfx stop

Motoko プログラミング入門: 複数のアクター&キャニスター

Thu, 30 Dec 2021 15:38:00 GMT

このページは、DFINITY の Motoko Language のチュートリアルを日本語で解説しています。

Use multiple actors

実際に使ったソースコードはGitHubからダウンロードできます。

はじめての方は先にこちらをご覧ください。

5 ステップではじめる Motoko プログラミング入門

実行環境

dfx: 0.8.4
macOS: 11.5.2
npm version: 8.1.3
任意のターミナル
任意のテキストエディタ

ターミナルとテキストエディタは好きなソフトウェアを使えば大丈夫です。

はじめは Mac 標準のターミナルでよいと思います。テキストエディタは筆者は Visual Studio Code を使っています。

本プロジェクトで学ぶこと

本プロジェクトでは、assistant, rock_paper_scissors, daemonの 3 つのキャニスターを作ります。それぞれのキャニスターの処理に関連性はありません。

手順

プロジェクトの作成

新しいプロジェクトを作ります。

dfx new multiple_actors
cd multiple_actors

dfx.json の編集

当プロジェクトでは、3 つのキャニスターを作ります。 dfx.json を以下のように書き換えます。

{
  "canisters": {
    "assistant": {
      "main": "src/assistant/main.mo",
      "type": "motoko"
    },
    "rock_paper_scissors": {
      "main": "src/rock_paper_scissors/main.mo",
      "type": "motoko"
    },
    "daemon": {
      "main": "src/daemon/main.mo",
      "type": "motoko"
    }
  },
  "defaults": {
    "build": {
      "args": "",
      "packtool": ""
    }
  },
  "dfx": "0.8.4",
  "networks": {
    "local": {
      "bind": "127.0.0.1:8000",
      "type": "ephemeral"
    }
  },
  "version": 1
}

dfx.json に書いたパスに Motoko のソースファイルをコピーします。

cp -r src/multiple_actors/ src/assistant/
cp -r src/assistant/ src/rock_paper_scissors/
cp -r src/assistant/ src/daemon/

コーディング

src/assistant/motoko.mo

import Array "mo:base/Array";
import Nat "mo:base/Nat";

// Define the actor
actor Assistant {

  stable var todos : [ToDo] = [];
  stable var nextId : Nat = 1;

  // Define to-do item properties
  type ToDo = {
    id : Nat;
    description : Text;
    completed : Bool;
  };

  // Add to-do item utility
  func add(todos : [ToDo], description : Text, id : Nat) : [ToDo] {
    let todo : ToDo = {
      id = id;
      description = description;
      completed = false;
    };
    Array.append(todos, [todo])
};

  // Show to-do item utility
  func show(todos : [ToDo]) : Text {
    var output : Text = "\n___TO-DOs___";
    for (todo : ToDo in todos.vals()) {
      output #= "\n(" # Nat.toText(todo.id) # ") " # todo.description;
      if (todo.completed) { output #= " ✔"; };
    };
    output
  };

  public func addTodo (description : Text) : async () {
    todos := add(todos, description, nextId);
    nextId += 1;
  };

  public query func showTodos () : async Text {
    show(todos)
  };

};

src/rock_paper_scissors/motoko.mo

import I "mo:base/Iter";

actor RockPaperScissors {

  stable var alice_score : Nat = 0;
  stable var bob_score : Nat = 0;
  stable var alice_last : Choice = #scissors;
  stable var bob_last : Choice = #rock;

  type Choice = {
    #rock;
    #paper;
    #scissors;
  };

  public func contest() : async Text {
    for (i in I.range(0, 99)) {
      battle_round();
    };
    var winner = "The contest was a draw";
    if (alice_score > bob_score) winner := "Alice won"
    else if (alice_score < bob_score) winner := "Bob won";
    return (winner);
  };

  func battle_round() : () {
    let a = alice(bob_last);
    let b = bob(alice_last);

    switch (a, b) {
      case (#rock, #scissors) alice_score += 1;
      case (#rock, #paper) bob_score += 1;
      case (#paper, #scissors) alice_score += 1;
      case (#paper, #rock) bob_score += 1;
      case (#scissors, #paper) alice_score += 1;
      case (#scissors, #rock) bob_score += 1;
      case (#rock, #rock) alice_score += 0;
      case (#paper, #paper) bob_score += 0;
      case (#scissors, #scissors) alice_score += 0;
    };

    alice_last := a;
    bob_last := b;

    return ();
  };

  // Hard-coded players and choices
  func bob(last : Choice) : Choice {
    return #paper;
  };

  func alice(last : Choice) : Choice {
    return #rock;
  };
};

src/daemon/main.mo

actor Daemon {
  stable var running = false;

  public func launch() : async Text {
    running := true;
    debug_show "The daemon process is running";
  };

  public func stop(): async Text {
    running := false;
    debug_show "The daemon is stopped";
  };
};

実行

assistant, rock_paper_scissors, daemonの 3 つのキャニスターを実行します。

dfx canister call assistant addTodo '("Schedule monthly demos")'
dfx canister call assistant showTodos
("
___TO-DOs___
(1) Schedule monthly demos")

dfx canister call rock_paper_scissors contest
("Bob won")

dfx canister call daemon launch
(""The daemon process is running"")

ローカル実行環境の停止

終わったらローカル PC 上の実行環境を停止します。

dfx stop

Motoko プログラミング入門: ライブラリを使って簡単な電話帳アプリを作ろう

Thu, 30 Dec 2021 06:38:00 GMT

このページでは DFINITY の Motoko Language のチュートリアルを日本語で解説しています。

Import library modules

実際に使ったソースコードはGitHubからダウンロードできます。

はじめての方は先にこちらをご覧ください。

5 ステップではじめる Motoko プログラミング入門

実行環境

dfx: 0.8.4
macOS: 11.5.2
npm version: 8.1.3
任意のターミナル
任意のテキストエディタ

ターミナルとテキストエディタは好きなソフトウェアを使えば大丈夫です。

はじめは Mac 標準のターミナルでよいと思います。テキストエディタは筆者は Visual Studio Code を使っています。

本プロジェクトで学ぶこと

phonebook というプロジェクトで phonebook というキャニスターを作ります。 phonebook では以下の機能を実装します。

insert関数では、nameとphoneを Key-Value としてbook変数に格納します。
lookup関数は、指定されたnameキーを入力として、関連するphoneを検索します。

手順

プロジェクトの作成

新しいプロジェクトを作ります。

dfx new phonebook
cd phonebook

コーディング

// Import standard library functions for lists

import L "mo:base/List";
import A "mo:base/AssocList";

// The PhoneBook actor.
actor {

    // Type aliases make the rest of the code easier to read.
    public type Name = Text;
    public type Phone = Text;

    // The actor maps names to phone numbers.
    flexible var book: A.AssocList<Name, Phone> = L.nil<(Name, Phone)>();

    // An auxiliary function checks whether two names are equal.
    func nameEq(l: Name, r: Name): Bool {
        return l == r;
    };

    // A shared invokable function that inserts a new entry
    // into the phone book or replaces the previous one.
    public func insert(name: Name, phone: Phone): async () {
        let (newBook, _) = A.replace<Name, Phone>(book, name, nameEq, ?phone);
        book := newBook;
    };

    // A shared read-only query function that returns the (optional)
    // phone number corresponding to the person with the given name.
    public query func lookup(name: Name): async ?Phone {
        return A.find<Name, Phone>(book, name, nameEq);
    };
};

コード解説

本チュートリアルのタイトルにもあるようにこのプロジェクトではライブラリを使っています。

import L "mo:base/List";
import A "mo:base/AssocList";

NameやPhoneというオリジナルの型を定義しています。 Text型の別名として考えることもできます。

type Name = Text;
type Phone = Text;

Motoko のチュートリアルで最初にここで躓く人は多いかもしれません。

    flexible var book: A.AssocList<Name, Phone> = L.nil<(Name, Phone)>();

この 1 行には、これまで登場しなかった要素がいくつも登場します。

flexible var
A.AssocList
<Name, Phone>
L.nil<(Name, Phone)>()

1 つずつ見ていきましょう！

flexible var

var宣言ではflexibleがデフォルトなので単にvarと書いたのと同じ意味になります。

AssocList

AssocList は Association List の略で連想配列です。

電話帳をイメージしてください。名前と電話番号がペアで、たくさんの件数が電話帳に入ります。

Key-Value が複数入るようなデータ構造が連想配列です。

<Name, Phone>

この記法はジェネリクスと呼ばれます。TypeScript や C++でも使われています。

詳しく知りたい場合は TypeScript や C++のジェネリクスに関する解説などを参考にしてください。

Name や Phone というオリジナルの型で AssocList を利用するため、このように書きます。

L.nil<(Name, Phone)>()

ここでもジェネリクスが使われています。

nil が予約語のように思えるかもしれませんが、これは List 型の関数名です。

nil()は空のリストを返します。この例では要素の型が<Name, Phone>という連想配列です。

デプロイ

ローカル実行環境を起動します。

dfx start --clean

通常は stop しても過去に作ったキャニスターは残っています。起動時に--cleanオプションを付けることで過去に作成したキャニスターは削除した状態で起動します。

ビルドしてキャニスターをデプロイします。

dfx deploy phonebook

実行

2 件の名前と電話番号情報をinsertします。

dfx canister call phonebook insert '("Chris Lynn", "01 415 792 1333")'
dfx canister call phonebook insert '("Maya Garcia", "01 408 395 7276")'

Chris Lynnのデータを連想配列bookの中から検索します。

phonebook % dfx canister call phonebook lookup '("Chris Lynn")'

出力
(opt "01 415 792 1333")

電話番号で逆引きするとどうなるでしょうか？

dfx canister call phonebook lookup '("01 408 395 7276")'

null を返します。

出力
(null)

2 人の名前を渡すとどうなるでしょうか？

phonebook % dfx canister call phonebook lookup '("Maya Garcia","Chris Lynn")'

最初に渡した名前の電話番号だけを返す実装になっています。

出力
(opt "01 408 395 7276")

Candid UI

Candid UI の使い方は、当ブログのほかの記事で解説しているので割愛します。

ローカル実行環境の停止

終わったらローカル PC 上の実行環境を停止します。

dfx stop

拡張

このプロジェクトでは、連想配列を DB のように扱うのでいろいろ改造してみると勉強になると思います。

下記の例では Email というフィールドを追加してみました。 src/phonebook/main2.mo

// Import standard library functions for lists

import L "mo:base/List";
import A "mo:base/AssocList";

// The PhoneBook actor.
actor {

    // Type aliases make the rest of the code easier to read.
    public type Name = Text;
    public type Phone = Text;
    public type Email = Text;

    // The actor maps names to phone numbers.
    flexible var book: A.AssocList<Name, Phone> = L.nil<(Name, Phone)>();
    flexible var addressBook: A.AssocList<Name, Email> = L.nil<(Name, Email)>();

    // An auxiliary function checks whether two names are equal.
    func nameEq(l: Name, r: Name): Bool {
        return l == r;
    };

    // A shared invokable function that inserts a new entry
    // into the phone book or replaces the previous one.
    public func insert(name: Name, phone: Phone, email: Email): async () {
        let (newBook, _) = A.replace<Name, Phone>(book, name, nameEq, ?phone);
        book := newBook;
        let (newAddressBook, _) = A.replace<Name, Email>(addressBook, name, nameEq, ?email);
        addressBook := newAddressBook;
    };

    // A shared read-only query function that returns the (optional)
    // phone number corresponding to the person with the given name.
    public query func lookupPhone(name: Name): async ?Phone {
        return A.find<Name, Phone>(book, name, nameEq);
    };
    public query func lookupEmail(name: Name): async ?Email {
        return A.find<Name, Email>(addressBook, name, nameEq);
    };
};

Motoko プログラミング入門: 簡単な数値計算をやってみよう

Wed, 29 Dec 2021 22:38:00 GMT

このページは、DFINITY の Motoko Language のチュートリアルを日本語で解説しています。

Use integers in calculator functions

実際に使ったソースコードはGitHubからダウンロードできます。

はじめての方は先にこちらをご覧ください。

5 ステップではじめる Motoko プログラミング入門

実行環境

dfx: 0.8.4
macOS: 11.5.2
npm version: 8.1.3
任意のターミナル
任意のテキストエディタ

ターミナルとテキストエディタは好きなソフトウェアを使えば大丈夫です。

はじめは Mac 標準のターミナルでよいと思います。テキストエディタは筆者は Visual Studio Code を使っています。

本プロジェクトで学ぶこと

calc というプロジェクトで calc キャニスターを作ります。 calc キャニスターは以下の関数を持ち、四則演算を実行します。

add
sub
mul
div
clearall

clearallでは結果のリセットを行います。

手順

プロジェクトの作成

新しいプロジェクトを作ります。

dfx new calc
cd calc

プロジェクトの構成変更

dfx.json にあるソースコードのファイル名をsrc/calc/calc_main.moに変更します。

"main": "src/calc/calc_main.mo",

デフォルトのsrc/calc/main.moをsrc/calc/calc_main.moにコピーします。

cp src/calc/main.mo src/calc/calc_main.mo

src/calc/calc_main.moを以下のように編集して保存します。

// This single-cell calculator defines one calculator instruction per
// public entry point (add, sub, mul, div).

// Create a simple Calc actor.
actor Calc {
  var cell : Int = 0;

  // Define functions to add, subtract, multiply, and divide
  public func add(n:Int) : async Int { cell += n; cell };
  public func sub(n:Int) : async Int { cell -= n; cell };
  public func mul(n:Int) : async Int { cell *= n; cell };
  public func div(n:Int) : async ?Int {
    if ( n == 0 ) {
      return null // null indicates div-by-zero error
    } else {
      cell /= n; ?cell
    }
  };

  // Clear the calculator and reset to zero
  public func clearall() : async Int {
    if (cell : Int != 0)
      cell -= cell;
    return cell
  };
 };

デプロイ

ローカルの実行環境を起動します。

dfx start

デプロイします。

dfx deploy

出力
Creating a wallet canister on the local network.
The wallet canister on the "local" network for user "default" is "rwlgt-iiaaa-aaaaa-aaaaa-cai"

<中略>

Committing batch.
Deployed canisters.

実行

add関数に 10 を渡して実行します。

calc % dfx canister call calc add '(10)'

出力
(10 : int)

mul関数に 3 を渡して実行します。(10 x 3)

dfx canister call calc mul '(3)'

出力
(30 : int)

sub関数に 5 を渡して実行します。(30 - 5)

dfx canister call calc sub '(5)'

出力
(25 : int)

div関数に 5 を渡して実行します。(25 / 5)

dfx canister call calc div '(5)'

出力
(opt (5 : int))

mul関数に-4 を渡して実行します。(5 x -4)

calc % dfx canister call calc mul '(-4)'

出力
(-20 : int)

clearall関数を実行してリセットします。

dfx canister call calc clearall

出力
(0 : int)

Candid UI を使った実行

ローカル実行環境の Candid キャニスター ID を確認します。

dfx canister id __Candid_UI

出力
r7inp-6aaaa-aaaaa-aaabq-cai

もし、実行環境が停止中なら起動します。

dfx start --background

先程のキャニスター ID に置き換えて、以下の URL にブラウザでアクセスします。

http://127.0.0.1:8000/?canisterId=<CANDID-UI-CANISTER-IDENTIFIER>

http://127.0.0.1:8000/?canisterId=r7inp-6aaaa-aaaaa-aaabq-cai

calcキャニスターの ID を取得して、ブラウザのProvide a canister IDに入力します。

calc % dfx canister id calc

以下のような画面が表示されます。

それぞれの関数をいろいろ試してみましょう！

実行環境の停止

終わったらローカル PC 上の実行環境を停止します。

dfx stop

Motoko プログラミング入門: Candid UI を使ってキャニスターを実行する

Wed, 29 Dec 2021 21:38:00 GMT

このページは、DFINITY(Internet Computer) の Motoko Language のチュートリアルを日本語で解説しています。

Increment a natural number

実際に使ったソースコードはGitHubからダウンロードできます。

はじめての方は先にこちらをご覧ください。

5 ステップではじめる Motoko プログラミング入門

実行環境

dfx: 0.8.4
macOS: 11.5.2
npm version: 8.1.3
任意のターミナル
任意のテキストエディタ

ターミナルとテキストエディタは好きなソフトウェアを使えば大丈夫です。

はじめは Mac 標準のターミナルでよいと思います。テキストエディタは筆者は Visual Studio Code を使っています。

手順

プロジェクトの作成

新しいプロジェクトを作ります。

dfx new my_counter
cd my_counter

ソースファイル名の変更

今回はmain.moというソースファイルの名前を変えます。 dfx.jsonの以下の行を変更します。

変更前
"main": "src/my_counter/main.mo",
変更後
"main": "src/my_counter/increment_counter.mo",

そして以下のコマンドでファイル名を変更します。

mv src/my_counter/main.mo src/my_counter/increment_counter.mo

コーディング

src/my_counter/increment_counter.moを以下のように編集して保存します。

// Create a simple Counter actor.
actor Counter {
  stable var currentValue : Nat = 0;

  // Increment the counter with the increment function.
  public func increment() : async () {
    currentValue += 1;
  };

  // Read the counter value with a get function.
  public query func get() : async Nat {
    currentValue
  };

  // Write an arbitrary value with a set function.
  public func set(n: Nat) : async () {
    currentValue := n;
  };
}

Counterという actor に 3 つの関数を定義しています。

increment
get
set

incrementはcurrentValueを+1 します。

起動

以下のどちらかのコマンドでローカル PC で実行環境を起動します。

dfx start

オプションをつけない場合、Ctrl+C で IC を停止するまで他のコマンドを実行できません。そのため別のターミナルウィンドウで他のコマンドを実行する必要があります。

dfx start --background

--backgroundをつけると起動後も同じウィンドウで他のコマンドを実行できます。

ビルド＆デプロイ

以下のコマンドでビルド&デプロイを実行します。

dfx deploy

dfx deployでは以下の 3 つの処理を一気に実行できます。

dfx canister create
dfx build
dfx canister install

コンパイルされていなければコンパイルしてからデプロイをしてくれます。

my_counter % dfx deploy
Creating a wallet canister on the local network.
The wallet canister on the "local" network for user "default" is "rwlgt-iiaaa-aaaaa-aaaaa-cai"
Deploying all canisters.

<中略>

Committing batch.
Deployed canisters.

実行

get increment set の 3 つの関数を使って実行します。

dfx canister call my_counter get

出力
(0 : nat)

初期値は 0 です。 incrementを実行してキャニスターが持つcurrentValueを+1 します。

dfx canister call my_counter increment

dfx canister call my_counter get

出力
(1 : nat)

結果が 1 になっています。

setを使って(987)を設定します。

dfx canister call my_counter set '(987)'
dfx canister call my_counter get

incrementで+1 します。

dfx canister call my_counter increment
dfx canister call my_counter get

currentValueは 988 になっています。

ブラウザから実行 (Candid UI)

このプロジェクトには、Candid UI というテスト用のキャニスターがデプロイされています。 Candid UI のキャニスター ID を確認してみましょう。

dfx canister id __Candid_UI

r7inp-6aaaa-aaaaa-aaabq-cai

ローカル IC にデプロイされたキャニスターの一覧は以下のファイルに保存されています。上のコマンドで表示された__Candid_UI というキャニスターもあります。

my_counter % cat .dfx/local/canister_ids.json
{
  "__Candid_UI": {
    "local": "r7inp-6aaaa-aaaaa-aaabq-cai"
  },
  "my_counter": {
    "local": "rrkah-fqaaa-aaaaa-aaaaq-cai"
  },
  "my_counter_assets": {
    "local": "ryjl3-tyaaa-aaaaa-aaaba-cai"
  }
}

もし、dfx stop で IC を停止していたら起動しましょう。

dfx start --background

ブラウザを使って以下の URL にアクセスします。

http://127.0.0.1:8000/?canisterId=<CANDID-UI-CANISTER-IDENTIFIER>

自分の環境の__Candid_UI のキャニスター ID に置き換えます。

http://127.0.0.1:8000/?canisterId=r7inp-6aaaa-aaaaa-aaabq-cai

my_counter % dfx canister id my_counter
rrkah-fqaaa-aaaaa-aaaaq-cai

以下のように Canister ID を入力する画面が表示されるはずです。

ここに my_counter のキャニスター ID を入力します。キャニスター ID はさっき確認した.dfx/local/canister_ids.jsonにも書かれていますが、以下のコマンドでも表示できます。

my_counter % dfx canister id my_counter

rrkah-fqaaa-aaaaa-aaaaq-cai

この ID をブラウザのフォームのProvide a canister ID:に入力します。

GO をクリックすると以下のような画面表示に変わります。

QUERY, CALL, RANDOM をクリックして自由に試してみましょう！

ローカル実行環境の停止

終わったらローカル PC 上の実行環境を停止します。

dfx stop

Motoko プログラミング入門: パラメータを渡してキャニスターを実行する

Wed, 29 Dec 2021 21:00:00 GMT

このページは、DFINITY の Motoko Language のチュートリアルを日本語で解説しています。

Pass text arguments

実際に使ったソースコードはGitHubからダウンロードできます。

はじめての方は先にこちらをご覧ください。

5 ステップではじめる Motoko プログラミング入門

実行環境

dfx: 0.8.4
macOS: 11.5.2
npm version: 8.1.3
任意のターミナル
任意のテキストエディタ

ターミナルとテキストエディタは好きなソフトウェアを使えば大丈夫です。

はじめは Mac 標準のターミナルでよいと思います。テキストエディタは筆者は Visual Studio Code を使っています。

プロジェクトの作成

新しいプロジェクトを作ります。

dfx new location_hello
cd location_hello

コーディング

src/location_hello/main.mo

actor {
  public func location(city : Text) : async Text {
    return "Hello, " # city # "!";
  };
};

location()という関数を定義します。 location()は city という Text の引数を取り、Text を返します。

実行環境の起動

dfx start

ビルド＆デプロイ

dfx deploy

実行

dfx canister call location_hello location "San Francisco"

出力
("Hello, San Francisco!")

dfx canister call location_hello location Paris

出力
("Hello, Paris!")

dfx canister call location_hello location '("San Francisco and Paris")'

出力
("Hello, San Francisco and Paris!")

location_hello の location 関数に、複数の都市名を渡してみましょう。

dfx canister call location_hello location '("San Francisco","Paris","Rome")'

複数の都市名を渡しても、この location()関数は、city1 つしか受け取らないので、最初の引数だけが使われます。

出力
("Hello, San Francisco!")

実行環境の停止

終わったらローカル PC 上の実行環境を停止します。

dfx stop

Motoko プログラミング入門: はじめてのアクター

Wed, 29 Dec 2021 20:38:00 GMT

このページは、DFINITY(Internet Computer) の Motoko Language チュートリアルを日本語で解説しています。

Query using an actor

実際に使ったソースコードはGitHubからダウンロードできます。

はじめての方は先にこちらをご覧ください。

5 ステップではじめる Motoko プログラミング入門

実行環境

dfx: 0.8.4
macOS: 11.5.2
npm version: 8.1.3
任意のターミナル
任意のテキストエディタ

ターミナルとテキストエディタは好きなソフトウェアを使えば大丈夫です。

はじめは Mac 標準のターミナルでよいと思います。テキストエディタは筆者は Visual Studio Code を使っています。

プロジェクトの作成

新しいプロジェクトを作ります。

dfx new actor_hello
cd actor_hello

不要なコードの削除

src/actor_hello_assetsを丸ごと削除します。

actor_hello % rm -r src/actor_hello_assets

dfx.jsonから以下の部分を削除します

    "actor_hello_assets": {
      "dependencies": [
        "actor_hello"
      ],
      "frontend": {
        "entrypoint": "src/actor_hello_assets/src/index.html"
      },
      "source": [
        "src/actor_hello_assets/assets",
        "dist/actor_hello_assets/"
      ],
      "type": "assets"
    }

コーディング

エディタを使って、src/actor_hello/main.mo を編集します。

import Debug "mo:base/Debug";
actor HelloActor {
   public query func hello() : async () {
      Debug.print ("Hello, World from DFINITY \n");
   }
};

ビルド前のチェック

ビルド前にチェックしてみます。

actor_hello % dfx build --check
Building canisters to check they build ok. Canister IDs might be hard coded.
Building canisters...

もしエラーが出た場合は、以下のような原因が考えられます。

dfx.json からactor_hello_assetsの部分を削除していない

--check オプションを付けると、一時的な Canister ID を使ってローカル環境でコンパイルを実行します。

コンパイルされた WASM ファイルは.dfx/local/canisters配下に作られています。

actor_hello % tree .dfx/local/canisters
.dfx/local/canisters
├── actor_hello
│   ├── actor_hello.did
│   ├── actor_hello.did.d.ts
│   ├── actor_hello.did.js
│   ├── actor_hello.wasm
│   └── index.js
└── idl

デプロイ

ローカルの実行環境を起動します。

dfx start --background

--backgroundオプションをつけることで、後続のコマンドを同じウィンドウで実行できます。

キャニスターを登録します。

dfx canister create actor_hello

出力結果
Creating a wallet canister on the local network.
The wallet canister on the "local" network for user "default" is "rwlgt-iiaaa-aaaaa-aaaaa-cai"
Creating canister "actor_hello"...
"actor_hello" canister created with canister id: "rrkah-fqaaa-aaaaa-aaaaq-cai"

ビルドします。

dfx build

デプロイします。

dfx canister install actor_hello

実行

デプロイしたキャニスターを実行しましょう。

dfx canister call actor_hello hello

actor_helloというキャニスターのhello()という関数を call しています。

dfx start を実行したウィンドウでは、以下のように出力されます。

[Canister rrkah-fqaaa-aaaaa-aaaaq-cai] Hello, World from DFINITY

停止

dfx.json があるディレクトリで以下のコマンドを実行して、実行環境を停止します。

dfx stop

Inside the Internet Computer

Mon, 27 Dec 2021 19:38:00 GMT

Medium

How ICP Works

https://dfinity.org/howitworks

Community Conversations

https://dfinity.org/conversations

Dev Forum

https://forum.dfinity.org/

YouTube

In-site Pages

Overview of DFINITY (Internet Computer)

Mon, 27 Dec 2021 18:38:00 GMT

DFINITY(ICP)

https://dfinity.org/

Internet Computer Association

https://internetcomputer.org/

The Internet Computer Review

https://medium.com/dfinity

Enter the ICP Ecosystem

https://internetcomputer.org/ecosystem

A Technical Overview of the Internet Computer

Medium

https://medium.com/dfinity/a-technical-overview-of-the-internet-computer-f57c62abc20f

YouTube

Genesis Launch Event

Education Center

https://internetcomputer.org/education

Dashboard

https://dashboard.internetcomputer.org/

In-site Pages

Dom's Foresight

Sun, 26 Dec 2021 19:38:00 GMT

Medium

https://dominic-w.medium.com/

Internet Computer <> Ethereum Integration Explained

May 28, 2021

Plans for ‘Endorphin,’ a Free and Open Crypto OS for Smartphones and Other End-User Devices

May 15, 2021

How Ethereum Could Be Supercharged by the Internet Computer Network

Aug 29,2020

Disentangling DFINITY and Ethereum

May 10, 2019

The Decentralized Cloud Vision of the DFINITY Blockchain

Jul 25, 2017

Future Governance? Integrating Traditional AI Technology Into the Blockchain Nervous System

Mar 21, 2017

Notes on protocols suitable for emerging Proof of Stake networks

Dec 2, 2016

Helo World. I’m back blogging!

May 16, 2016

Remix の使い方: Metamask でスマートコントラクトをデプロイ

Mon, 01 Nov 2021 10:38:00 GMT

この記事はこんな人におすすめ

メインネットにスマコンをデプロイしたい人
自分のオリジナルトークンを作りたい人
Remix の使い方を知りたい人
Solidity の本を買ったけど、次に何をするかわからない人

じつはメインネットにスマコンを作るのは、PC 上の開発環境に作るより簡単です！

作業はすべて Remix という Web サービスを使うので、ブラウザさえあれば誰でも進められます。

Remix にコードをコピペしてボタンを 2, 3 回クリックすればなんとスマコンは完成します！

基本的に Remix は無料で利用できます。

Remix の作業に必要な３ステップさえ覚えれば、本物のブロックチェーンにオリジナルトークンも作れるようになるのでやってみよう！

はじめに

必要となるツール

Metamask

利用するネットワーク

Ropsten (Ethereum のテストネット)
Binance Smart Chain (メインネット)

ブロックチェーンにスマートコントラクトをデプロイするために、Remix と Metamask を使います。

Remix は無料で利用できますが、ブロックチェーンのメインネットにデプロイするにはそのチェーンの利用料(Transaction Fee)がかかります。

BSC(Binance Smart Chain)ならだいたい数十円ぐらいです。(2021 年 5 月現在) もし BNB という仮想通貨を持っていない場合は、Ethereum のテストネット Ropsten にデプロイしましょう。Ropsten のようなテストネットなら Fee はもらえます。

注意：Metamask の開発に使うアカウントは仮想通貨トレードに使うアカウントとわけてください。誤って高額な Transaction Fee がかかったり、大事な秘密鍵を間違ったトランザクションに使ったりすることを防ぐためです。

Remix

https://remix.ethereum.org/

なんだか難しそうな画面がでてきます。でも、まだ閉じないで！

Remix の使い方を全部理解する必要はありません。スマコンのデプロイに必要な場所は３箇所だけです。

一番左のところを見てください。使うのは上から３つのアイコンです。

FILE EXPLORERS
SOLIDITY COMPILER
DEPLOY & RUN TRANSACTIONS

FILE EXPLORERS

１番上は FILE EXPLORERS、コードを書く場合に使います。コードは 100%コピペで大丈夫です。

SOLIDITY COMPILER

上から２番目がコンパイラです。プログラムをコンパイルしてスマートコントラクトコードを作ります。人間が読み書きできるテキストコードから機械が処理するコードに変換します。

DEPLOY & RUN TRANSACTIONS

３番目はデプロイする画面です。コンパイルしたスマコンをブロックチェーン上にデプロイします。デプロイするときには Metamask を使います。

それでは実際に Remix を使ってスマコンを作っていきましょう！

スマートコントラクトの作成

コーディング（コピペ OK）

今回はもっともシンプルなコードを使います。おなじみの Hello World です。

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;

contract HelloWorld {
  function get() public pure returns (string memory) {
    return "Hello World";
  }
}

まず FILE EXPLORERS を開いて、contracts ディレクトリの下に New File を作ります。ファイル名は HelloWorld.sol にします。

ファイルを作ったらさっきのコードをコピペしましょう。

Solidity のコンパイル

これでコードは完成です。つぎはコンパイルです。

上から２番目のアイコンの SOLIDITY COMPILER を開きます。開いたら「Compile HelloWorld.sol」をクリックします。

これでスマコンの出来上がり！なんかあっけないですね

ブロックチェーンにスマコンをデプロイ

最後にデプロイです。上から３番目のアイコンの DEPLOY & RUN TRANSACTIONS を開きます。 CONTRACT のところに HelloWorld が表示されていることを確認しましょう。これはさっきコンパイルした HelloWorld コントラクトです。

ENVIRONMENT を Injected Web3 に変更する

ここからが大事なポイントです。 ENVIRONMENT を変更します。デフォルトでは「JavaScript VM」になっていますが、Metamask を使うためにここを「Injected Web3」に変更します。

これで Metamask を使う設定になりました。

Metamask はネットワーク設定で接続先のブロックチェーンを切り替えることができます。

Remix からデプロイを実行すると Metamask が現在つないでいるブロックチェーンのネットワークにデプロイできます。

MetamaskでBSCを選択　→　RemixからBSCへデプロイ
MetamaskでRopstenを選択　→　RemixからRopstenへデプロイ
MetamaskでGanacheを選択　→　RemixからPC上のGanacheテストネットにデプロイ

Ropsten へのデプロイ

まずは、Ethereum のテストネット Ropsten にデプロイしてみましょう。

デプロイ時には Transaction Fee が必要になります。もしテストネットの ETH を持っていない場合は先に入手しましょう。

デプロイ前の３つの確認事項

以下の３点を確認しましょう

Remix の ENVIRONMENT が Intected Web3 になっていること
Metamask のネットワークが Ropsten になっていること
Metamask アカウントに ETH 残高があること

注意：もし、誤って本番ネットワークが選択されている場合は、Transaction Fee として本物の仮想通貨を消費します。必ずダブルチェックしましょう。

Remix を使ったスマートコントラクトのデプロイ

確認できたら Deploy をクリックします。

Gas 代の確認

Metamask の確認画面が表示されます。新しいコントラクトのデプロイを選択中のネットワークに対して実行します。

Gas 代を確認して「確認」をクリックします。

トランザクションの確認（新しいスマートコントラクトの作成）

Remix のデプロイ画面の右下の動いているログの中に Ropsten の Etherscan へのリンクがあります。そのリンク先を開くと、トランザクションのステータスがわかります。

Success になっていれば成功 Pending はまだ処理中 Failed は失敗

Etherscan (Ropsten)

デプロイが成功したらスマコンを実行してみましょう。

スマコンの実行確認(Ropsten)

DEPLOY & RUN TRANSACTIONS の左下に Deployed Contracts という場所があります。デプロイが正常に完了していれば、ここに HELLOWORLD コントラクトがあるはずです。

HELLOWORLD を開くと「get」というボタンが出てきます。

この get はあなたが作ったスマートコントラクトの命令です。

HelloWorld コントラクトの get()ファンクション

今回使っている HelloWorld のコードをもう 1 回見てみましょう。コードの中で get というファンクションを作っています。ファンクションとはスマートコントラクトに対する命令のことです。メソッドや関数とも言います。

 function get() public pure returns (string memory) {
   return "Hello World";
 }

今回あなたが作ったのは、get()を実行すると”Hello World”という文字を返すファンクションを持つスマートコントラクトだったのです。

Remix で get ボタンを押してみましょう。Gas 代はかかりません。

すぐ下に string: Hello World という文字が表示されています。あなたがデプロイしたスマートコントラクトから返された文字です。

このスマコンは Ropsten ブロックチェーン上にあるので、Remix 以外の web3.js からでももちろん実行することができます。

ここまで到達したあなたなら、コピーするコードを変えるだけでどんなスマコンでも作ることができます！

最後に BSC(Binance Smart Chain)へのデプロイを説明します。

BSC へのデプロイ

Ropsten のときとやることは同じです。変わるのは Metamask の接続先のネットワークだけ。

Metamask のネットワーク設定

すでに BNB を持っているあなたは Metamask に BSC の設定が入っていると思いますが、一応設定を Metamask 用のネットワーク設定を載せておきます。

Binance Smart Chain
https://bsc-dataseed.binance.org/
56
BNB
https://bscscan.com/

デプロイ前の 4 つの確認事項

Remix の DEPLOY & RUN TRANSACTIONS 画面では、以下の 4 点を確認しましょう。

Remix の ENVIRONMENT が Intected Web3 になっていること
Remix の CONTRACT で HelloWorld が選択されていること
Metamask のネットワークが BSC になっていること
Metamask アカウントに BNB 残高があること

それでは Deploy をクリックしましょう。

デプロイ時の注意事項

メインネットにデプロイするときは、Metamask の確認画面で必ず高額な Gas 代を払っていないことを確認しましょう。

トランザクションが混雑している場合に、一時的に Gas 代が高騰したり、誤って Gas 代の高い Ethreum のメインネットを選択していたら、10 倍以上の仮想通貨を消費してしまうことも起こります。

メインネットで作業するときは必ずダブルチェックしましょう。

デプロイのステータス確認

デプロイが成功したかどうか確認します。

Ropsten にデプロイしたときは、Remix の右下にあるログの URL から Ropsten のサイトに飛んで確認しました。今回は BSC のメインネットなので、BscScan というサイトで確認できます。

Metamask のアクティビティから BscScan のサイトへ飛んでみましょう。

BscScan（エクスプローラ）を使った確認

BscScan のサイトの中身は Ropsten のときの Ethersacn と同じです。

Success になっていれば、あなたのスマコンが Binance Smart Chain にデプロイされています。これでもう、あなたは Web3 エンジニアです！

スマートコントラクトの実行

最後にデプロイしたスマコンを実行してみます。Ropsten のときと同じように Remix の DEPLOY & RUN TRANSACTIONS から実行します。

対象のネットワーク設定には Metamask の設定を使います。 Deploy のときと同じように以下の 2 点を確認します。

ENVIRONMENT が Injected Web3 になっていること Metamask のネットワークが BSC になっていること

左下の Deployed Contracts で HelloWorld スマコンを選んで get をクリックします。

【コピペで OK】オジリナル仮想通貨のつくり方（ERC20）

Thu, 22 Apr 2021 10:38:00 GMT

この記事はこんな人におすすめ

オリジナル仮想通貨を作りたい人（非エンジニア向け）
Solidity の本を買ったけど、次に何をするかわからない人
ブロックチェーンの仕組みを知りたい人

自分だけのオリジナル仮想通貨を本物のブロックチェーンのメインネットに作ってみましょう。

Binance Smart Chain というブロックチェーンに作りますが、Metamask で繋がるブロックチェーンなら同じ方法で作れます。

Metamask が使えるチェーン

Ethereum
Polygon
Fantom
Aavalanche など

当記事は開発者向けではなく、非エンジニアでも作れるように説明します。コードは 100%コピペすれば OK です。

エンジニアの方にはこちらの記事がオススメです。

Hardhat の使い方: 初心者向けのスマートコントラクト開発

それではさっそく始めましょう！

免責事項

当記事では、本物の仮想通貨を使用する情報を掲載していますが、当記事の情報によって起きるいかなる結果にも筆者は責任を負いません。

はじめに

利用する Web サービス（無料） https://remix.ethereum.org

必要なもの

Metamask
0.01 BNB ぐらい（日本円で数百円ぐらい）

注意スマートコントラクトのデプロイには、専用の Metamask 環境を用意しましょう。仮想通貨のトレードに使うウォレットとわけましょう。

今回の作業では Metamask を使って Binance Smart Chain（以降 BSC と表示）のメインネットに接続します。

本番のメインネットにスマートコントラクトをデプロイするには、Transaction Fee が必要です。BSC なら 0.01 BNB ぐらいあれば足りると思います。

作業前の前提として以下の準備が必要です。

Metamask から Binance Smart Chain に繋いでいること
Metamask の BSC のアカウントに 0.01 BNB 以上持っていること

Binance Smart Chain 上の BNB を入手したり送金する方法は当記事では解説しません。

Remix でスマートコントラクトを作る

Remix はスマートコントラクトの Web 型の開発環境です。 https://remix.ethereum.org/

コードを書いたり、コンパイルしたり、ブロックチェーンにデプロイしたりできます。

今回使うコードは用意してあるので 100%コピペで大丈夫です。

Remix で使うのは以下の 3 箇所です。

FILE EXPLORERS

最初に、FILE EXPLORERS という画面ででコードをコピペします。左側にはファイルツリーが表示されて、右側にファイルの編集画面が表示されています。

contracts というフォルダの下に、MyToken.sol というファイルを作って右側に下のコードをコピペします。

MyToken というのがトークンの名前です。TKN が通貨の単位です。自分の好きな名前に置換すれば、オリジナルの名前で作れます。

// contracts/SimpleToken.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {
  /**
   * @dev Constructor that gives msg.sender all of existing tokens.
   */
  constructor (uint256 initialSupply
  ) public ERC20("MyToken", "TKN") {
      _mint(msg.sender, initialSupply * 10 ** uint(decimals()));
  }
}

これでコーディングは完了！今日からあなたも Solidity エンジニアです。

次はコンパイルです。

SOLIDITY COMPILER

SOLIDITY COMPILER という画面を開きましょう。

開いたら Complie MyToken.sol をクリックします。

バージョンの違いで、下のような Warning が表示されますが、無視して OK です。

Warning: Visibility for constructor is ignored. If you want the contract to be non-deployable, making it “abstract” is sufficient. —> contracts/MyToken.sol:11:3: | 11 | constructor (uint256 initialSupply | ^ (Relevant source part starts here and spans across multiple lines).

ほかに何もエラーが出なければコンパイル完了です。

あとはこのコンパイルしたスマートコントラクトをブロックチェーンにデプロイしたら完成です。

Metamask が Binance Smart Chain に繋がっていることを確認しましょう。

DEPLOY & RUN TRANSACTIONS

DEPLOY & RUN TRANSACTIONS を開きましょう。Deploy する前にいくつか確認するポイントがあります。

ENVIRONEMNT を「Injected Web3」に変える
ACCOUNT が Metamask のアドレスになっていること
CONTRACT が先ほどコンパイルした MyToken になっていること

トークンの供給量を決めます。今回は 10,000 にするとして、Deploy ボタンの隣に半角で「10000」と入力します。

全部確認できればいよいよデプロイです。Deploy をクリックしましょう。 Metamask のトランザクション承認画面が表示されます。

トランザクションの承認画面では Gas 代を確認しましょう。

Gas 代はタイミングによって変わります。今回は 0.006244 BNB でした。

問題なければ確認をクリックしましょう。何もエラーが出なければオリジナルトークンの完成です。

オリジナルトークンをウォレットに追加しよう

作ったオリジナルトークンをウォレットに追加してみましょう。

スマートコントラクトは、ウォレットと同じようにブロックチェーン上のアドレスを持っています。そのアドレスは DEPLOY & RUN TRANSACTION 画面の左下からコピーできます。

コントラクトアドレスをコピーしたら、Metamask の「トークンを追加」に入力しましょう。

無事に Metamask に MyToken を 10,000TKN 登録できました！

もちろん、作ったトークンは BSC のほかのアドレスに送ることができます。

smacon.dev

About Sakanosita IC Labs | smacon.dev

Welcome to Sakanosita IC Labs! 🎉

What we do 🚀

Get in touch 📬

No title

はじめてのスマートコントラクト開発 | Web3 プログラミング入門

smacon.dev

Motoko ではじめるキャニスター開発 | ICP プログラミング学習

Cycle Wallet キャニスター図解: dfx identity (Principal ID), Ledger (Account ID)との関係

dfx identity

Ledger Account

Canisters

Cycle Wallet

上の図には書いていない説明

Internet Computer 入門: メインネットにキャニスターをデプロイする手順

前提

本日のゴール

Cycle トークン・ウォレットとは

注意事項

Deploying to Internet Computer

おまけ: キャニスターの Cycle を引き出してウォレットに入れる

5ステップではじめる Motoko プログラミング | DFINITY ICP 入門

はじめに

必要なスキル、前提知識

実行環境

ステップ 1: dfx(SDK)をインストールする

ステップ 2: Hello World プロジェクトを作る

ステップ 3: ローカル実行環境を起動する

ステップ 4: ビルドしてデプロイする

ステップ 5: Hello World プログラムを実行する

解説

Start Coding for DFINITY

INTERNET COMPUTER Developer Docs

Sample Code

Motoko SDK

Rust SDK

Dev Forum

NFID

Community Consideration

Community Conversations

Links

In-site Pages

イーサリアム入門: オラクルのしくみ（Chainlink Data Feeds）

構成要素の説明

Consumer

Proxy

Aggregator

Off Chain Node

OCR (Off Chain Reporting)

実際の Aggregator の state を覗いてみよう

Proxy

Aggregator

ラウンド ID

answer

startedAt/updatedAt

実際のレポート提出トランザクションを見てみよう

Solidity ではじめるスマートコントラクト入門 | Web3 プログラミング学習

Hardhat の使い方: 初心者向けの Solidity 開発入門

インストール

Hardhat プロジェクトの作成

プラグインの追加

スマートコントラクトの作成

コーディング

hardhat.config.js

contracts/Token.sol

コンパイル

テスト

test/Token.js

テストネットへのデプロイ

scripts/deploy.js

hardhat.config.js

Ropsten にデプロイ

Metamask で確認

Solidity / Hardhat の使い方: イーサリアムのテストネットにデプロイしよう！

Ethereum のテストネットについて

事前準備

EOA の秘密鍵

テストネット の ETH トークン

RPC エンドポイントの URL

テストネットの ETH トークン