第十二課 從寵物商店案例看DAPP架構和WEB3.JS交互接口
1. 文章摘要
【本文目標】 瞭解ETH生態下DAPP去中心化應用程序的框架和交互流程，瞭解WEB3.JS的做用和接口函數。 【前置條件】 完成了《第六課 技術小白如何開發一個DAPP區塊鏈應用(以寵物商店爲例)》的學習實踐，對智能合約瞭解。 【技術收穫】 1). DAPP架構 2). ETH節點框架 3).寵物商店的APP.js文件的業務處理流程圖和函數介紹 4).web3.js接口 【實操課程列表】 第一課 如何在WINDOWS環境下搭建以太坊開發環境 第二課 如何實現以太坊最簡智能合約「Hello World」的運行 第四課 以太坊開發框架Truffle從入門到實戰 第六課 技術小白如何開發一個DAPP區塊鏈應用(以寵物商店爲例) 第七課 技術小白如何在45分鐘內發行通證(TOKEN)並上線交易 第八課 如何調試以太坊官網的智能合約衆籌案例 第九課 如何在Remix環境下進行Solidity代碼單步調試 第十課 Solidity語言編輯器REMIX指導大全 第十一課 從寵物商店案例看DAPP架構和WEB3.JS交互接口html
【說明】未列出的課程爲知識普及的非實操類課程，全部區塊鏈文章參考「區塊鏈入口」專欄。node
2. 以太坊節點和DAPP框架
2.1 以太坊節點架構
交易數據 以太坊中每筆交易都存儲在區塊鏈上。當你部署合約時，一次部署就是一筆交易。當你爲候選者投票時，一次投票 又是另外一筆交易。全部的這些交易都是公開的，每一個人均可以看到並進行驗證。這個數據永遠也沒法篡改。jquery
爲了確保網絡中的全部節點都有着同一份數據拷貝，而且沒有向數據庫中寫入任何無效數據，以太坊 目前使用工做量證實 （POW：Proof Of Work）算法來保證網絡安全，即經過礦工挖礦（Mining）來達成共識（Consensus）—— 將數據同步到全部節點。 工做量證實不是達成共識的惟一算法，挖礦也不是區塊鏈的惟一選擇。如今，咱們只須要了解，共識是指各節點 的數據實現了一致，POW只是衆多用於創建共識的算法中的一種，這種算法須要經過礦工的挖礦來實現非可信環境下的 可信交易。共識是目的，POW是手段。 合約代碼 以太坊不只僅在鏈上存儲交易數據，它還能夠在鏈上存儲合約代碼。 在數據庫層面，區塊鏈的做用就是存儲交易數據。那麼給候選者投票、或者檢索投票結果的邏輯放在哪兒呢？ 在以太坊的世界裏，你可使用Solidity語言來編寫業務邏輯/應用代碼（也就是合約：Contract）， 而後將合約代碼編譯爲以太坊字節碼，並將字節碼部署到區塊鏈上： git
##2.2 DAPP架構 下圖給出了基於以太坊的去中心化應用架構： github
Web3.js是以太坊官方的Javascript API，能夠幫助智能合約開發者使用HTTP或者IPC與本地的或者遠程的以太坊節點交互。實際上就是一個庫的集合，主要包括下面幾個庫：web
web3-eth用來與以太坊區塊鏈和智能合約交互web3-shh用來控制whisper協議與p2p通訊以及廣播web3-bzz用來與swarm協議交互web3-utils包含了一些Dapp開發有用的功能
Web3與geth通訊使用的是 JSON-RPC ，這是一種輕量級的RPC（Remote Procedure Call）協議，整個通訊的模型能夠抽象爲下圖。 ajax
#3. 以寵物商店爲例WEB3.JS代碼 第六課 技術小白如何開發一個DAPP區塊鏈應用(以寵物商店爲例) 這篇文章詳細介紹了一個寵物商店DAPP的案例。本節重點分析引用WEB3.JS相關接口代碼。算法
##3.1 加註釋的app.js代碼數據庫
App = {
web3Provider: null,
contracts: {},
init: function() {
/*加載寵物名字，圖片，年齡，位置等信息*/
// Load pets.
$.getJSON('../pets.json', function(data) {
var petsRow = $('#petsRow');
var petTemplate = $('#petTemplate');
for (i = 0; i < data.length; i ++) {
petTemplate.find('.panel-title').text(data[i].name);
petTemplate.find('img').attr('src', data[i].picture);
petTemplate.find('.pet-breed').text(data[i].breed);
petTemplate.find('.pet-age').text(data[i].age);
petTemplate.find('.pet-location').text(data[i].location);
petTemplate.find('.btn-adopt').attr('data-id', data[i].id);
petsRow.append(petTemplate.html());
}
});
return App.initWeb3();
},
initWeb3: function() {
/*若是web3事先被定義，則使用當前web3實例的錢包對象。例如remix下JavaScript VM建立的虛擬錢包（有4個含100個 ETH的帳戶）；
或者MetaMask連接後的帳戶錢包；或者mist錢包*/
if (typeof web3 !== 'undefined') {
App.web3Provider = web3.currentProvider;
} else {
// If no injected web3 instance is detected, fall back to Ganache
/*若是web3不存在，則啓動本地啓動的Ganache錢包。[前提：要啓動好本地的Ganache環境哦，不然會建立不成功]*/
App.web3Provider = new Web3.providers.HttpProvider('http://localhost:7545');
}
/*建立Web3實例，入口參數爲剛纔配置的App.web3Provider*/
web3 = new Web3(App.web3Provider);
/*調用初始化合約函數*/
return App.initContract();
},
initContract: function() {
/*參考 http://www.w3school.com.cn/jquery/ajax_getjson.asp 獲取getJSON到的方法*/
$.getJSON('Adoption.json', function(data) {
// Get the necessary contract artifact file and instantiate it with truffle-contract
var AdoptionArtifact = data;
App.contracts.Adoption = TruffleContract(AdoptionArtifact);
// 設置當前合約的web3Provider錢包提供者
App.contracts.Adoption.setProvider(App.web3Provider);
// 使用咱們的合約去提取和標識已領養的寵物
return App.markAdopted();
});
/*返回綁定事件*/
return App.bindEvents();
},
/*點擊含有'.btn-adopt'類的click事件會觸發handleAdopt(處理領養)的函數*/
bindEvents: function() {
$(document).on('click', '.btn-adopt', App.handleAdopt);
},
/*若是該寵物已被領養，則文字顯示爲"Success"，按鈕不可點擊*/
markAdopted: function(adopters, account) {
var adoptionInstance;
App.contracts.Adoption.deployed().then(function(instance) {
adoptionInstance = instance;
return adoptionInstance.getAdopters.call();
}).then(function(adopters) {
for (i = 0; i < adopters.length; i++) {
/*若是領養者的地址不是爲0，則設置按鈕字體和狀態，*/
if (adopters[i] !== '0x0000000000000000000000000000000000000000') {
$('.panel-pet').eq(i).find('button').text('Success').attr('disabled', true);
}
}
}).catch(function(err) {
console.log(err.message);
});
},
handleAdopt: function(event) {
event.preventDefault();
/*parseInt() 函數可解析一個字符串，並返回一個整數。*/
var petId = parseInt($(event.target).data('id'));
var adoptionInstance;
/*獲取當前ETH錢包的帳號*/
web3.eth.getAccounts(function(error, accounts) {
if (error) {
console.log(error);
}
/*取第一個錢包帳號*/
var account = accounts[0];
/*ES6的then函數調用，鏈式調用*/
App.contracts.Adoption.deployed().then(function(instance) {
adoptionInstance = instance;
// 經過發送帳戶執行adopt領養函數的交易的返回值
// 此處沒有搞懂，智能合約Adoption.adopt只有一個入參，此處爲何增長了第二個{from: account}參數呢？
//TINY熊認爲，把它當作語法就能夠， 要麼提早設置默認帳號， 要麼調用時指定
return adoptionInstance.adopt(petId, {from: account});
}).then(function(result) {
/*標識領養狀態*/
return App.markAdopted();
/*輸出錯誤*/
}).catch(function(err) {
console.log(err.message);
});
});
}
};
/*窗口加載即調用App.init函數*/
$(function() {
$(window).load(function() {
App.init();
});
});
複製代碼
##3.2 app.js調用WEB3流程分析 json
#4. Web3 JavaScript app API 參考 Web3的官網文檔給出了詳細的接口文檔和說明。
- web3
- web3.net
- web3.eth
- web3.eth.defaultAccount
- web3.eth.defaultBlock
- web3.eth.syncing
- web3.eth.isSyncing
- web3.eth.coinbase
- web3.eth.mining
- web3.eth.hashrate
- web3.eth.gasPrice
- web3.eth.accounts
- web3.eth.blockNumber
- web3.eth.register
- web3.eth.unRegister
- web3.eth.getBalance
- web3.eth.getStorageAt
- web3.eth.getCode
- web3.eth.getBlock
- web3.eth.getBlockTransactionCount
- web3.eth.getUncle
- web3.eth.getTransaction
- web3.eth.getTransactionFromBlock
- web3.eth.getTransactionReceipt
- web3.eth.getTransactionCount
- web3.eth.sendTransaction
- web3.eth.sendRawTransaction
- web3.eth.sign
- web3.eth.call
- web3.eth.estimateGas
- web3.eth.filter
- web3.eth.contract
- web3.eth.getCompilers
- web3.eth.compile.solidity
- web3.eth.compile.lll
- web3.eth.compile.serpent
- web3.eth.namereg
- web3.db
web3
web3對象提供了全部方法。
示例:
//初始化過程
var Web3 = require('web3');
if (typeof web3 !== 'undefined') {
web3 = new Web3(web3.currentProvider);
} else {
// set the provider you want from Web3.providers
web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:8545"));
}
複製代碼
web3.version.api
web3.version.api
返回值：
String - 以太坊js的api版本
示例：
//省略初始化過程
var version = web3.version.api;
console.log(version);
$ node test.js
0.18.2
複製代碼
web3.version.node
同步方式：
web3.verison.node
異步方式：
web3.version.getNode(callback(error, result){ ... })
返回值：
String - 客戶端或節點的版本信息
示例：
//省略初始化過程
var version = web3.version.node;
console.log(version);
$ node test.js
EthereumJS TestRPC/v3.0.3/ethereum-js
複製代碼
web3.version.network
同步方式：
web3.version.network
異步方式：
web3.version.getNetwork(callback(error, result){ ... })
返回值:
String - 網絡協議版本
示例：
//省略初始化過程
var version = web3.version.network;
console.log(version);
$ node test.js
1488546587563
複製代碼
web3.version.ethereum
同步方式：
web3.version.ethereum
異步方式：
web3.version.getEthereum(callback(error, result){ ... })
返回值：
String - 以太坊的協議版本
示例：
//省略初始化過程
var version = web3.version.ethereum;
console.log(version);
$ node test.js
60
複製代碼
注意：EthereumJS testRPC客戶端不支持這個命令，報錯Error: Error: RPC method eth_protocolVersion not supported.
web3.version.whisper
同步方式：
web3.version.whisper
異步方式：
web3.version.getWhisper(callback(error, result){ ... })
返回值：
String - whisper協議的版本
示例：
//省略初始化過程
var version = web3.version.whisper;
console.log(version);
$ node test.js
20
複製代碼
注意：EthereumJS testRPC客戶端不支持這個命令，報錯Error: Error: RPC method shh_version not supported.
web3.isConnected
web3.isConnected
能夠用來檢查到節點的鏈接是否存在（connection to node exist）。
參數：
無
返回值：
Boolean
示例：
//省略初始化過程
var connected = web3.isConnected();
if(!connected){
console.log("node not connected!");
}else{
console.log("node connected");
}
複製代碼
web3.setProvider
web3.setProvider
設置Provider
參數：
無
返回值：
undefined
示例：
web3.setProvider(new web3.providers.HttpProvider('http://localhost:8545'));
複製代碼
web3.currentProvider
web3.currentProvider
若是已經設置了Provider，則返回當前的Provider。這個方法能夠用來檢查在使用mist瀏覽器等狀況下已經設置過Provider，避免重複設置的狀況。
返回值：
Object - null 或 已經設置的Provider。
示例：
if(!web3.currentProvider)
web3.setProvider(new web3.providers.HttpProvider("http://localhost:8545"));
複製代碼
web3.reset
web3.reset
用來重置web3的狀態。重置除了manager之外的其它全部東西。卸載filter，中止狀態輪詢。
參數：
- Boolean - 若是設置爲
true，將會卸載全部的filter，但會保留web3.eth.isSyncing()的狀態輪詢。
返回值：
undefined
示例：
//省略初始化過程
console.log("reseting ... ");
web3.reset();
console.log("is connected:" + web3.isConnected());
$ node test.js
reseting ...
is connected:true
複製代碼
web3.sha3
web3.sha3(string, options)
參數：
String- 傳入的須要使用Keccak-256 SHA3算法進行哈希運算的字符串。Object- 可選項設置。若是要解析的是hex格式的十六進制字符串。須要設置encoding爲hex。由於JS中會默認忽略0x。
返回值：
String - 使用Keccak-256 SHA3算法哈希過的結果。
示例：
//省略初始化過程
var hash = web3.sha3("Some string to be hashed");
console.log(hash);
var hashOfHash = web3.sha3(hash, {encoding: 'hex'});
console.log(hashOfHash);
複製代碼
web3.toHex
web3.toHex
將任何值轉爲HEX。
參數：
String|Number|Object|Array|BigNumber- 須要轉化爲HEX的值。若是是一個對象或數組類型，將會先用JSON.stringify1進行轉換成字符串。若是傳入的是BigNumber2，則將獲得對應的Number的HEX。
示例：
//初始化基本對象
var Web3 = require('web3');
var web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:8545"));
var BigNumber = require('bignumber.js');
var str = "abcABC";
var obj = {abc: 'ABC'};
var bignumber = new BigNumber('12345678901234567890');
var hstr = web3.toHex(str);
var hobj = web3.toHex(obj);
var hbg = web3.toHex(bignumber);
console.log("Hex of Sring:" + hstr);
console.log("Hex of Object:" + hobj);
console.log("Hex of BigNumber:" + hbg);
$ node test.js
Hex of Sring:0x616263414243
Hex of Object:0x7b22616263223a22414243227d
Hex of BigNumber:0xab54a98ceb1f0ad2
複製代碼
web3.toAscii
web3.toAscii(hexString)
將HEX字符串轉爲ASCII3字符串
參數：
String- 十六進制字符串。
返回值：
String - 給定十六進制字符串對應的ASCII碼值。
示例：
var str = web3.toAscii("0x657468657265756d000000000000000000000000000000000000000000000000");
console.log(str); // "ethereum"
複製代碼
web3.fromAscii
web3.fromAscii
將任何的ASCII碼字符串轉爲HEX字符串。
參數：
String-ASCII碼字符串Number- 返回的字符串字節大小，不夠長會自動填充。
返回值：
String - 轉換後的HEX字符串。
示例：
var str = web3.fromAscii('ethereum');
console.log(str); // "0x657468657265756d"
var str2 = web3.fromAscii('ethereum', 32);
console.log(str2); // "0x657468657265756d000000000000000000000000000000000000000000000000"
$ node test.js
0x657468657265756d
0x657468657265756d
複製代碼
備註： 填充padding功能好像不可用4。
web3.toDecimal
web3.toDecimal
將一個十六進制轉爲一個十進制的數字
參數：
String- 十六進制字符串
返回：
Number - 傳入字符串所表明的十六進制值。
示例：
var number = web3.toDecimal('0x15');
console.log(number); // 21
複製代碼
web3.fromDecimal
web3.fromDecimal
將一個數字，或者字符串形式的數字轉爲一個十六進制串。
參數：
Number|String- 數字
返回值：
String - 給定數字對應的十六進制表示。
示例：
var value = web3.fromDecimal('21');
console.log(value); // "0x15"
複製代碼
web3.fromWei
web3.fromWei(number, 單位)
以太坊貨幣單位之間的轉換。將以wei爲單位的數量，轉爲下述的單位，可取值以下：
- kwei/ada
- mwei/babbage
- gwei/shannon
- szabo
- finney
- ether
- kether/grand/einstein
- mether
- gether
- tether
參數：
Number|String|BigNumber- 數字或BigNumber。String- 單位字符串
返回值：
String|BigNumber - 根據傳入參數的不一樣，分別是字符串形式的字符串，或者是BigNumber。
示例：
var value = web3.fromWei('21000000000000', 'finney');
console.log(value); // "0.021"
複製代碼
web3.toWei
web3.toWei(number, 單位)
按對應貨幣轉爲以wei爲單位。可選擇的單位以下：
- kwei/ada
- mwei/babbage
- gwei/shannon
- szabo
- finney
- ether
- kether/grand/einstein
- mether
- gether
- tether
參數：
Number|String|BigNumber- 數字或BigNumberString- 字符串單位
返回值：
String|BigNumber - 根據傳入參數的不一樣，分別是字符串形式的字符串，或者是BigNumber。
示例：
var value = web3.toWei('1', 'ether');
console.log(value); // "1000000000000000000"
複製代碼
web3.toBigNumber
web3.toBigNumber(數字或十六進制字符串)
將給定的數字或十六進制字符串轉爲BigNumber5。
參數：
Number|String- 數字或十六進制格式的數字
返回值：
BigNumber - BigNumber的實例
示例：
var value = web3.toBigNumber('200000000000000000000001');
console.log(value); // instanceOf BigNumber
console.log(value.toNumber()); // 2.0000000000000002e+23
console.log(value.toString(10)); // '200000000000000000000001'
複製代碼
web3.net
web3.net.listening
同步方式：
web3.net.listening
異步方式：
web3.net.getListener(callback(error, result){ ... })
此屬性是隻讀的，表示當前鏈接的節點，是否正在listen網絡鏈接與否。listen能夠理解爲接收。
返回值：
Boolean - true表示鏈接上的節點正在listen網絡請求，不然返回false。
示例：
var listening = web3.net.listening;
console.log("client listening: " + listening);
$ node test.js
client listening: true
複製代碼
備註： 若是關閉咱們要鏈接的測試節點，會報錯Error: Invalid JSON RPC response: undefined。因此這個方法返回的是咱們連上節點的listen狀態。
web3.net.peerCount
同步方式：
web3.net.peerCount
異步方式：
web3.net.getPeerCount(callback(error, result){ ... })
屬性是隻讀的，返回鏈接節點已連上的其它以太坊節點的數量。
返回值：
Number - 鏈接節點連上的其它以太坊節點的數量
示例：
var peerCount = web3.net.peerCount;
console.log("Peer count: " + peerCount);
$ node test.js
Peer count: 0
複製代碼
web3.eth
包含以太坊區塊鏈相關的方法
示例：
var eth = web3.eth;
複製代碼
web3.eth.defaultAccount
web3.eth.defaultAccount
默認的地址在使用下述方法時使用，你也能夠選擇經過指定from屬性，來覆蓋這個默認設置。
- web3.eth.sendTransaction()
- web3.eth.call()
默認值爲undefined，20字節大小，任何你有私匙的你本身的地址。
返回值：
String - 20字節的當前設置的默認地址。
示例：
console.log("Current default: " + web3.eth.defaultAccount);
web3.eth.defaultAccount = '0x8888f1f195afa192cfee860698584c030f4c9db1';
console.log("Current default: " + web3.eth.defaultAccount);
$ node test.js
Current default: undefined
Current default: 0x8888f1f195afa192cfee860698584c030f4c9db1
複製代碼
web3.eth.defaultBlock
web3.eth.defaultBlock
使用下述方法時，會使用默認塊設置，你也能夠經過傳入defaultBlock來覆蓋默認配置。
- web3.eth.getBalance()
- web3.eth.getCode()
- web3.eth.getTransactionCount()
- web3.eth.getStorageAt()
- web3.eth.call()
- contract.myMethod.call()
- contract.myMethod.estimateGas()
可選的塊參數，可能下述值中的一個：
Number- 區塊號String-earliest，創世塊。String-latest，最近剛出的最新塊，當前的區塊頭。String-pending，當前正在mine的區塊，包含正在打包的交易。
默認值是latest
返回值：
Number|String - 默認要查狀態的區塊號。
示例：
console.log("defaultBlock: " + web3.eth.defaultBlock);
web3.eth.defaultBlock = 231;
console.log("defaultBlock: " + web3.eth.defaultBlock);
$ node test.js
defaultBlock: latest
defaultBlock: 231
複製代碼
web3.eth.syncing
同步方式：
web3.eth.syncing
異步方式：
web3.eth.getSyncing(callback(error, result){ ... })
這個屬性是隻讀的。若是正在同步，返回同步對象。不然返回false。
返回值：
Object|Boolean - 若是正在同步，返回含下面屬性的同步對象。不然返回false。
返回值：
startingBlock：Number- 同步開始區塊號currentBlock:Number- 節點當前正在同步的區塊號highestBlock:Number- 預估要同步到的區塊
var sync = web3.eth.syncing;
console.log(sync);
$ node test.js
false
//正在sync的狀況
$ node test.js
{
startingBlock: 300,
currentBlock: 312,
highestBlock: 512
}
複製代碼
web3.eth.isSyncing
web3.eth.isSyncing(callback)
提供同步開始，更新，中止的回調函數方法。
返回值：
Object - 一個syncing對象，有下述方法：
syncing.addCallback(): 增長另外一個回調函數，在節點開始或中止調用時進行調用。syncing.stopWatching(): 中止同步回調。
回調返回值：
Boolean- 同步開始時，此值爲true，同步中止時此回調值爲false。Object- 當正在同步時，會返回同步對象。startingBlock：Number- 同步開始區塊號currentBlock:Number- 節點當前正在同步的區塊號highestBlock:Number- 預估要同步到的區塊
示例：
//初始化基本對象
var Web3 = require('web3');
var web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:8545"));
var BigNumber = require('bignumber.js');
web3.eth.isSyncing(function(error, sync){
if(!error) {
// stop all app activity
if(sync === true) {
// we use `true`, so it stops all filters, but not the web3.eth.syncing polling
web3.reset(true);
// show sync info
} else if(sync) {
console.log(sync.currentBlock);
// re-gain app operation
} else {
// run your app init function...
}
}
});
複製代碼
web3.eth.coinbase
同步方式：
web3.eth.coinbase
異步方式：
web3.eth.getCoinbase(callback(error, result){ ... })
只讀屬性，節點配置的，若是挖礦成功獎勵的地址。
返回值：
String - 節點的挖礦獎勵地址。
示例：
var coinbase = web3.eth.coinbase;
console.log(coinbase); // "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
複製代碼
web3.eth.mining
同步方式：
web3.eth.mining
異步方式：
web3.eth.getMining(callback(error, result){ ... })
屬性只讀，表示該節點是否配置挖礦。
返回值：
Boolean - true 表示配置挖礦，不然表示沒有。
var mining = web3.eth.mining;
console.log(mining); // true or false
複製代碼
web3.eth.hashrate
同步方式：
web3.eth.hashrate
異步方式：
web3.eth.getHashrate(callback(error, result){ ... })
屬性只讀，表示的是當前的每秒的哈希難度。
返回值：
Number - 每秒的哈希數
示例：
var hashrate = web3.eth.hashrate;
console.log(hashrate);
複製代碼
web3.eth.gasPrice
同步方式：
web3.eth.gasPrice
異步方式：
web3.eth.getGasPrice(callback(error, result){ ... })
屬性是隻讀的，返回當前的gas價格。這個值由最近幾個塊的gas價格的中值6決定。
返回值：
BigNumber - 當前的gas價格的BigNumber實例，以wei爲單位。
var gasPrice = web3.eth.gasPrice;
console.log(gasPrice.toString(10)); // "10000000000000"
複製代碼
web3.eth.accounts
同步方式：
web3.eth.accounts
異步方式：
web3.eth.getAccounts(callback(error, result){ ... })
只讀屬性，返回當前節點持有的賬戶列表。
返回值：
Array - 節點持有的賬戶列表。
示例：
var accounts = web3.eth.accounts;
console.log(accounts);
複製代碼
web3.eth.blockNumber
同步方式：
web3.eth.blockNumber
異步方式：
web3.eth.getBlockNumber(callback(error, result){ ... })
屬性只讀，返回當前區塊號。
var number = web3.eth.blockNumber;
console.log(number); // 2744
複製代碼
web3.eth.register
web3.eth.register(addressHexString [, callback])
（暫未實現）將給定地址註冊到web3.eth.accounts。這將容許無私匙的賬戶，如合約被關聯到有私匙的賬戶，如合約錢包。
參數：
String- 要註冊的地址。Function-（可選）回調函數，用於支持異步的方式執行7。
返回值：
待肯定
示例：
web3.eth.register("0x407d73d8a49eeb85d32cf465507dd71d507100ca")
複製代碼
web3.eth.unRegister
異步方式
web3.eth.unRegister(addressHexString [, callback])
（暫未實現）取消註冊給定地址
參數：
String- 要取消註冊的地址Function- （可選） 回調函數，用於支持異步的方式執行7。
返回值：
待肯定
示例：
web3.eth.unRegister("0x407d73d8a49eeb85d32cf465507dd71d507100ca")
複製代碼
web3.eth.getBalance
web3.eth.getBalance(addressHexString [, defaultBlock] [, callback])
得到在指定區塊時給定地址的餘額。
參數：
String- 要查詢餘額的地址。Number|String-（可選）若是不設置此值使用web3.eth.defaultBlock設定的塊，不然使用指定的塊。Funciton- （可選）回調函數，用於支持異步的方式執行7。
返回值：
String - 一個包含給定地址的當前餘額的BigNumber實例，單位爲wei。
示例：
var balance = web3.eth.getBalance("0x407d73d8a49eeb85d32cf465507dd71d507100c1");
console.log(balance); // instanceof BigNumber
console.log(balance.toString(10)); // '1000000000000'
console.log(balance.toNumber()); // 1000000000000
複製代碼
web3.eth.getStorageAt
web3.eth.getStorageAt(addressHexString, position [, defaultBlock] [, callback])
得到某個地址指定位置的存儲的狀態值。
合約由控制執行的EVM字節碼和用來保存狀態的
Storage兩部分組成。Storage在區塊鏈上是以均爲32字節的鍵，值對的形式進行存儲8。
參數：
String- 要得到存儲的地址。Number- 要得到的存儲的序號Number|String-（可選）若是未傳遞參數，默認使用web3.eth.defaultBlock定義的塊，不然使用指定區塊。Function- 回調函數，用於支持異步的方式執行7。
返回值：
String - 給定位置的存儲值
示例：
var state = web3.eth.getStorageAt("0x407d73d8a49eeb85d32cf465507dd71d507100c1", 0);
console.log(state); // "0x03"
複製代碼
web3.eth.getCode
web3.eth.getCode(addressHexString [, defaultBlock] [, callback])
獲取指定地址的代碼
參數：
String- 要得到代碼的地址。Number|String-（可選）若是未傳遞參數，默認使用web3.eth.defaultBlock定義的塊，不然使用指定區塊。Function- 回調函數，用於支持異步的方式執行7。
返回值：
String - 給定地址合約編譯後的字節代碼。
示例：
var code = web3.eth.getCode("0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8");
console.log(code); // "0x600160008035811a818181146012578301005b601b6001356025565b8060005260206000f25b600060078202905091905056"
複製代碼
web3.eth.getBlock
web3.eth.getBlock(blockHashOrBlockNumber [, returnTransactionObjects] [, callback])
返回塊號或區塊哈希值所對應的區塊
參數：
Number|String-（可選）若是未傳遞參數，默認使用web3.eth.defaultBlock定義的塊，不然使用指定區塊。Boolean-（可選）默認值爲false。true會將區塊包含的全部交易做爲對象返回。不然只返回交易的哈希。Function- 回調函數，用於支持異步的方式執行7。
返回值 - 區塊對象：
Number- 區塊號。當這個區塊處於pending將會返回null。hash- 字符串，區塊的哈希串。當這個區塊處於pending將會返回null。parentHash- 字符串，32字節的父區塊的哈希值。nonce- 字符串，8字節。POW生成的哈希。當這個區塊處於pending將會返回null。sha3Uncles- 字符串，32字節。叔區塊的哈希值。logsBloom- 字符串，區塊日誌的布隆過濾器9。當這個區塊處於pending將會返回null。transactionsRoot- 字符串，32字節，區塊的交易前綴樹的根。stateRoot- 字符串，32字節。區塊的最終狀態前綴樹的根。miner- 字符串，20字節。這個區塊得到獎勵的礦工。difficulty-BigNumber類型。當前塊的難度，整數。totalDifficulty-BigNumber類型。區塊鏈到當前塊的總難度，整數。extraData- 字符串。當前塊的extra data字段。size-Number。當前這個塊的字節大小。- gasLimit -
Number，當前區塊容許使用的最大gas。 gasUsed- 當前區塊累計使用的總的gas。timestamp-Number。區塊打包時的unix時間戳。transactions- 數組。交易對象。或者是32字節的交易哈希。uncles- 數組。叔哈希的數組。
示例：
var info = web3.eth.getBlock(3150);
console.log(info);
/*
{
"number": 3,
"hash": "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46",
"parentHash": "0x2302e1c0b972d00932deb5dab9eb2982f570597d9d42504c05d9c2147eaf9c88",
"nonce": "0xfb6e1a62d119228b",
"sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
"logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"transactionsRoot": "0x3a1b03875115b79539e5bd33fb00d8f7b7cd61929d5a3c574f507b8acf415bee",
"stateRoot": "0xf1133199d44695dfa8fd1bcfe424d82854b5cebef75bddd7e40ea94cda515bcb",
"miner": "0x8888f1f195afa192cfee860698584c030f4c9db1",
"difficulty": BigNumber,
"totalDifficulty": BigNumber,
"size": 616,
"extraData": "0x",
"gasLimit": 3141592,
"gasUsed": 21662,
"timestamp": 1429287689,
"transactions": [
"0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b"
],
"uncles": []
}
*/
複製代碼
web3.eth.getBlockTransactionCount
web3.eth.getBlockTransactionCount(hashStringOrBlockNumber [, callback])
返回指定區塊的交易數量。
參數：
Number|String-（可選）若是未傳遞參數，默認使用web3.eth.defaultBlock定義的塊，不然使用指定區塊。Function- 回調函數，用於支持異步的方式執行7。
返回值：
Nubmer - 給定區塊的交易數量。
示例：
var number = web3.eth.getBlockTransactionCount("0x407d73d8a49eeb85d32cf465507dd71d507100c1");
console.log(number); // 1
複製代碼
web3.eth.getUncle
web3.eth.getUncle(blockHashStringOrNumber, uncleNumber [, returnTransactionObjects] [, callback])
經過指定叔位置，返回指定叔塊。
參數：
Number|String-（可選）若是未傳遞參數，默認使用web3.eth.defaultBlock定義的塊，不然使用指定區塊。Number- 叔的序號。Boolean-（可選）默認值爲false。true會將區塊包含的全部交易做爲對象返回。不然只返回交易的哈希。Function- 回調函數，用於支持異步的方式執行7。
返回值：
Object - 返回的叔塊。返回值參考web3.eth.getBlock()。
備註： 叔塊沒有本身的交易數據。
示例：
var uncle = web3.eth.getUncle(500, 0);
console.log(uncle); // see web3.eth.getBlock
複製代碼
web3.eth.getTransaction
web3.eth.getTransaction(transactionHash [, callback])
返回匹配指定交易哈希值的交易。
參數：
String- 交易的哈希值。Function- 回調函數，用於支持異步的方式執行7。
返回值：
Object - 一個交易對象
hash:String- 32字節，交易的哈希值。nonce:Number- 交易的發起者在以前進行過的交易數量。blockHash:String- 32字節。交易所在區塊的哈希值。當這個區塊處於pending將會返回null。blockNumber:Number- 交易所在區塊的塊號。當這個區塊處於pending將會返回null。transactionIndex:Number- 整數。交易在區塊中的序號。當這個區塊處於pending將會返回null。from:String- 20字節，交易發起者的地址。to:String- 20字節，交易接收者的地址。當這個區塊處於pending將會返回null。value:BigNumber- 交易附帶的貨幣量，單位爲Wei。gasPrice:BigNumber- 交易發起者配置的gas價格，單位是wei。gas:Number- 交易發起者提供的gas。.input:String- 交易附帶的數據。
示例：
var blockNumber = 668;
var indexOfTransaction = 0
var transaction = web3.eth.getTransaction(blockNumber, indexOfTransaction);
console.log(transaction);
/*
{
"hash": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b",
"nonce": 2,
"blockHash": "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46",
"blockNumber": 3,
"transactionIndex": 0,
"from": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
"to": "0x6295ee1b4f6dd65047762f924ecd367c17eabf8f",
"value": BigNumber,
"gas": 314159,
"gasPrice": BigNumber,
"input": "0x57cb2fc4"
}
*/
複製代碼
web3.eth.getTransactionFromBlock
getTransactionFromBlock(hashStringOrNumber, indexNumber [, callback])
複製代碼
返回指定區塊的指定序號的交易。
參數：
String- 區塊號或哈希。或者是earliest，latest或pending。查看web3.eth.defaultBlock瞭解可選值。Number- 交易的序號。Function- 回調函數，用於支持異步的方式執行7。
返回值：
Object - 交易對象，詳見web3.eth.getTransaction
示例：
var transaction = web3.eth.getTransactionFromBlock('0x4534534534', 2);
console.log(transaction); // see web3.eth.getTransaction
複製代碼
web3.eth.getTransactionReceipt
web3.eth.getTransactionReceipt(hashString [, callback])
經過一個交易哈希，返回一個交易的收據。
備註：處於pending狀態的交易，收據是不可用的。
參數：
String- 交易的哈希Function- 回調函數，用於支持異步的方式執行7。
返回值：
Object - 交易的收據對象，若是找不到返回null
blockHash:String- 32字節，這個交易所在區塊的哈希。blockNumber:Number- 交易所在區塊的塊號。transactionHash:String- 32字節，交易的哈希值。transactionIndex:Number- 交易在區塊裏面的序號，整數。from:String- 20字節，交易發送者的地址。to:String- 20字節，交易接收者的地址。若是是一個合約建立的交易，返回null。cumulativeGasUsed:Number- 當前交易執行後累計花費的gas總值10。gasUsed:Number- 執行當前這個交易單獨花費的gas。contractAddress:String- 20字節，建立的合約地址。若是是一個合約建立交易，返回合約地址，其它狀況返回null。logs:Array- 這個交易產生的日誌對象數組。
示例：
var receipt = web3.eth.getTransactionReceipt('0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b');
console.log(receipt);
{
"transactionHash": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b",
"transactionIndex": 0,
"blockHash": "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46",
"blockNumber": 3,
"contractAddress": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
"cumulativeGasUsed": 314159,
"gasUsed": 30234,
"logs": [{
// logs as returned by getFilterLogs, etc.
}, ...]
}
複製代碼
web3.eth.getTransactionCount
web3.eth.getTransactionCount(addressHexString [, defaultBlock] [, callback])
返回指定地址發起的交易數。
參數：
String- 要得到交易數的地址。Number|String-（可選）若是未傳遞參數，默認使用web3.eth.defaultBlock定義的塊，不然使用指定區塊。Function- 回調函數，用於支持異步的方式執行7。
返回值：
Number - 指定地址發送的交易數量。
示例：
var number = web3.eth.getTransactionCount("0x407d73d8a49eeb85d32cf465507dd71d507100c1");
console.log(number); // 1
複製代碼
web3.eth.sendTransaction
web3.eth.sendTransaction(transactionObject [, callback])
發送一個交易到網絡。
參數：
Object- 要發送的交易對象。from:String- 指定的發送者的地址。若是不指定，使用web3.eth.defaultAccount。to:String- （可選）交易消息的目標地址，若是是合約建立，則不填.value:Number|String|BigNumber- （可選）交易攜帶的貨幣量，以wei爲單位。若是合約建立交易，則爲初始的基金。gas:Number|String|BigNumber- （可選）默認是自動，交易可以使用的gas，未使用的gas會退回。gasPrice:Number|String|BigNumber- （可選）默認是自動肯定，交易的gas價格，默認是網絡gas價格的平均值 。data:String- （可選）或者包含相關數據的字節字符串，若是是合約建立，則是初始化要用到的代碼。nonce:Number- （可選）整數，使用此值，能夠容許你覆蓋你本身的相同nonce的，正在pending中的交易11。
Function- 回調函數，用於支持異步的方式執行7。
返回值：
String - 32字節的交易哈希串。用16進製表示。
若是交易是一個合約建立，請使用web3.eth.getTransactionReceipt()在交易完成後獲取合約的地址。
示例：
// compiled solidity source code using https://chriseth.github.io/cpp-ethereum/
var code = "603d80600c6000396000f3007c01000000000000000000000000000000000000000000000000000000006000350463c6888fa18114602d57005b6007600435028060005260206000f3";
web3.eth.sendTransaction({data: code}, function(err, address) {
if (!err)
console.log(address); // "0x7f9fade1c0d57a7af66ab4ead7c2eb7b11a91385"
});
複製代碼
web3.eth.sendRawTransaction
web3.eth.sendRawTransaction(signedTransactionData [, callback])
發送一個已經簽名的交易。好比能夠用下述簽名的例子：github.com/SilentCicer…
參數：
String- 16進制格式的簽名交易數據。Function- 回調函數，用於支持異步的方式執行7。
返回值：
String - 32字節的16進制格式的交易哈希串。
若是交易是一個合約建立，請使用web3.eth.getTransactionReceipt()在交易完成後獲取合約的地址。
示例：
var Tx = require('ethereumjs-tx');
var privateKey = new Buffer('e331b6d69882b4cb4ea581d88e0b604039a3de5967688d3dcffdd2270c0fd109', 'hex')
var rawTx = {
nonce: '0x00',
gasPrice: '0x09184e72a000',
gasLimit: '0x2710',
to: '0x0000000000000000000000000000000000000000',
value: '0x00',
data: '0x7f7465737432000000000000000000000000000000000000000000000000000000600057'
}
var tx = new Tx(rawTx);
tx.sign(privateKey);
var serializedTx = tx.serialize();
//console.log(serializedTx.toString('hex'));
//0xf889808609184e72a00082271094000000000000000000000000000000000000000080a47f74657374320000000000000000000000000000000000000000000000000000006000571ca08a8bbf888cfa37bbf0bb965423625641fc956967b81d12e23709cead01446075a01ce999b56a8a88504be365442ea61239198e23d1fce7d00fcfc5cd3b44b7215f
web3.eth.sendRawTransaction(serializedTx.toString('hex'), function(err, hash) {
if (!err)
console.log(hash); // "0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385"
});
複製代碼
web3.eth.sign
web3.eth.sign(address, dataToSign, [, callback])
使用指定賬戶簽名要發送的數據，賬戶須要處於unlocked狀態。
參數：
String- 簽名使用的地址String- 要簽名的數據Function-（可選）回調函數，用於支持異步的方式執行7。
返回值：
String - 簽名後的數據。
返回的值對應的是ECDSA（Elliptic Curve Digital Signature Algorithm）12簽名後的字符串。
r = signature[0:64]
s = signature[64:128]
v = signature[128:130]
複製代碼
須要注意的是，若是你使用ecrecover，這裏的v值是00或01，因此若是你想使用他們，你須要把這裏的v值轉成整數，再加上27。最終你要用的值將是27或2813。
示例：
var result = web3.eth.sign("0x135a7de83802408321b74c322f8558db1679ac20",
"0x9dd2c369a187b4e6b9c402f030e50743e619301ea62aa4c0737d4ef7e10a3d49"); // second argument is web3.sha3("xyz")
console.log(result); // "0x30755ed65396facf86c53e6217c52b4daebe72aa4941d89635409de4c9c7f9466d4e9aaec7977f05e923889b33c0d0dd27d7226b6e6f56ce737465c5cfd04be400"
複製代碼
備註：若是你使用以太坊的客戶端進行簽名時，它們會在你要簽名的數據前增長前綴\x19Ethereum Signed Message:\n14，感謝讀者**@劉兵**同窗的反饋。
eth_sign
The sign method calculates an Ethereum specific signature with: sign(keccak256("\x19Ethereum Signed Message:\n" + len(message) + message))).
By adding a prefix to the message makes the calculated signature recognisable as an Ethereum specific signature. This prevents misuse where a malicious DApp can sign arbitrary data (e.g. transaction) and use the signature to impersonate the victim.
web3.eth.call
web3.eth.call(callObject [, defaultBlock] [, callback])
在節點的VM中，直接執行消息調用交易。但不會將數據合併區塊鏈中（這樣的調用不會修改狀態）。
參數：
Object- 返回一個交易對象，同web3.eth.sendTransaction。與sendTransaction的區別在於，from屬性是可選的。Number|String-（可選）若是不設置此值使用web3.eth.defaultBlock設定的塊，不然使用指定的塊。Function-（可選）回調函數，用於支持異步的方式執行7。
返回值：
String - 函數調用返回的值。
示例：
var Web3 = require('web3');
if (typeof web3 !== 'undefined') {
web3 = new Web3(web3.currentProvider);
} else {
// set the provider you want from Web3.providers
web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:8545"));
}
var from = web3.eth.accounts[0];
//部署合約的發佈地址
/*合約內容以下
pragma solidity ^0.4.0;
contract Calc{
function add(uint a, uint b) returns (uint){
return a + b;
}
}
*/
var to = "0xa4b813d788218df688d167102e5daff9b524a8bc";
//要發送的數據
//格式說明見： http://me.tryblockchain.org/Solidity-call-callcode-delegatecall.html
var data = "0x771602f700000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002";
var result = web3.eth.call({
from : from,
to : to,
data : data
});
//返回結果32字長的結果3
console.log(result);
複製代碼
web3.eth.estimateGas
web3.eth.estimateGas(callObject [, callback])
在節點的VM節點中執行一個消息調用，或交易。可是不會合入區塊鏈中。返回使用的gas量。
參數：
同web3.eth.sendTransaction，全部的屬性都是可選的。
返回值：
Number - 模擬的call/transcation花費的gas。
示例：
var result = web3.eth.estimateGas({
to: "0xc4abd0339eb8d57087278718986382264244252f",
data: "0xc6888fa10000000000000000000000000000000000000000000000000000000000000003"
});
console.log(result); // "0x0000000000000000000000000000000000000000000000000000000000000015"
複製代碼
web3.eth.filter
參數：
String|Object- 字符串的可取值[latest，pending]。latest表示監聽最新的區塊變化，pending表示監聽正在pending的區塊。若是須要按條件對象過濾，以下：fromBlock:Number|string- 起始區塊號（若是使用字符串latest，意思是最新的，正在打包的區塊），默認值是latest。toBlock:Number|string- 終止區塊號（若是使用字符串latest，意思是最新的，正在打包的區塊），默認值是latest。address:String- 單個或多個地址。獲取指定賬戶的日誌。topics:String[]- 在日誌對象中必須出現的字符串數組。順序很是重要，若是你想忽略主題，使用null。如，[null,'0x00...']，你還能夠爲每一個主題傳遞一個單獨的可選項數組，如[null,['option1','option1']]。
返回值：
Object - 有下述方法的過濾對象。
filter.get(callback): 返回知足過濾條件的日誌。filter.watch(callback): 監聽知足條件的狀態變化，知足條件時調用回調7。filter.stopWatching(): 中止監聽，清除節點中的過濾。你應該老是在監聽完成後，執行這個操做。
監聽回調返回值：
String- 當使用latest參數時。返回最新的一個區塊哈希值。String- 當使用pending參數時。返回最新的pending中的交易哈希值。Object- 當使用手工過濾選項時，將返回下述的日誌對象。logIndex:Number- 日誌在區塊中的序號。若是是pending的日誌，則爲null。transactionIndex:Number- 產生日誌的交易在區塊中的序號。若是是pending的日誌，則爲null。transactionHash:String，32字節 - 產生日誌的交易哈希值。blockHash:String，32字節 - 日誌所在塊的哈希。若是是pending的日誌，則爲null。blockNumber:Number- 日誌所在塊的塊號。若是是pending的日誌，則爲null。address:String，32字節 - 日誌產生的合約地址。data:string- 包含日誌一個或多個32字節的非索引的參數。topics:String[]- 一到四個32字節的索引的日誌參數數組。（在Solidity中，第一個主題是整個事件的簽名（如，Deposit(address,bytes32,uint256)），但若是使用匿名的方式定義事件的狀況除外）
事件監聽器的返回結果，見後合約對象的事件。
示例：
var filter = web3.eth.filter('pending');
filter.watch(function (error, log) {
console.log(log); // {"address":"0x0000000000000000000000000000000000000000", "data":"0x0000000000000000000000000000000000000000000000000000000000000000", ...}
});
// get all past logs again.
var myResults = filter.get(function(error, logs){ ... });
...
// stops and uninstalls the filter
filter.stopWatching();
複製代碼
web3.eth.contract
web3.eth.contract(abiArray)
建立一個Solidity的合約對象，用來在某個地址上初始化合約。
參數：
Array- 一到多個描述合約的函數，事件的ABI對象。
返回值：
Object - 一個合約對象。
示例：
var MyContract = web3.eth.contract(abiArray);
// instantiate by address
var contractInstance = MyContract.at([address]);
// deploy new contract
var contractInstance = MyContract.new([contructorParam1] [, contructorParam2], {data: '0x12345...', from: myAccount, gas: 1000000});
// Get the data to deploy the contract manually
var contractData = MyContract.new.getData([contructorParam1] [, contructorParam2], {data: '0x12345...'});
// contractData = '0x12345643213456000000000023434234'
複製代碼
你能夠或者使用一個在某個地址上已經存在的合約，或者使用編譯後的字節碼部署一個全新的的合約。
// Instantiate from an existing address:
var myContractInstance = MyContract.at(myContractAddress);
// Or deploy a new contract:
// Deploy the contract asyncronous from Solidity file:
...
const fs = require("fs");
const solc = require('solc')
let source = fs.readFileSync('nameContract.sol', 'utf8');
let compiledContract = solc.compile(source, 1);
let abi = compiledContract.contracts['nameContract'].interface;
let bytecode = compiledContract.contracts['nameContract'].bytecode;
let gasEstimate = web3.eth.estimateGas({data: bytecode});
let MyContract = web3.eth.contract(JSON.parse(abi));
var myContractReturned = MyContract.new(param1, param2, {
from:mySenderAddress,
data:bytecode,
gas:gasEstimate}, function(err, myContract){
if(!err) {
// NOTE: The callback will fire twice!
// Once the contract has the transactionHash property set and once its deployed on an address.
// e.g. check tx hash on the first call (transaction send)
if(!myContract.address) {
console.log(myContract.transactionHash) // The hash of the transaction, which deploys the contract
// check address on the second call (contract deployed)
} else {
console.log(myContract.address) // the contract address
}
// Note that the returned "myContractReturned" === "myContract",
// so the returned "myContractReturned" object will also get the address set.
}
});
// Deploy contract syncronous: The address will be added as soon as the contract is mined.
// Additionally you can watch the transaction by using the "transactionHash" property
var myContractInstance = MyContract.new(param1, param2, {data: myContractCode, gas: 300000, from: mySenderAddress});
myContractInstance.transactionHash // The hash of the transaction, which created the contract
myContractInstance.address // undefined at start, but will be auto-filled later
複製代碼
示例：
// contract abi
var abi = [{
name: 'myConstantMethod',
type: 'function',
constant: true,
inputs: [{ name: 'a', type: 'string' }],
outputs: [{name: 'd', type: 'string' }]
}, {
name: 'myStateChangingMethod',
type: 'function',
constant: false,
inputs: [{ name: 'a', type: 'string' }, { name: 'b', type: 'int' }],
outputs: []
}, {
name: 'myEvent',
type: 'event',
inputs: [{name: 'a', type: 'int', indexed: true},{name: 'b', type: 'bool', indexed: false}]
}];
// creation of contract object
var MyContract = web3.eth.contract(abi);
// initiate contract for an address
var myContractInstance = MyContract.at('0xc4abd0339eb8d57087278718986382264244252f');
// call constant function
var result = myContractInstance.myConstantMethod('myParam');
console.log(result) // '0x25434534534'
// send a transaction to a function
myContractInstance.myStateChangingMethod('someParam1', 23, {value: 200, gas: 2000});
// short hand style
web3.eth.contract(abi).at(address).myAwesomeMethod(...);
// create filter
var filter = myContractInstance.myEvent({a: 5}, function (error, result) {
if (!error)
console.log(result);
/*
{
address: '0x8718986382264244252fc4abd0339eb8d5708727',
topics: "0x12345678901234567890123456789012", "0x0000000000000000000000000000000000000000000000000000000000000005",
data: "0x0000000000000000000000000000000000000000000000000000000000000001",
...
}
*/
});
複製代碼
合約對象的方法
// Automatically determines the use of call or sendTransaction based on the method type
myContractInstance.myMethod(param1 [, param2, ...] [, transactionObject] [, defaultBlock] [, callback]);
// Explicitly calling this method
myContractInstance.myMethod.call(param1 [, param2, ...] [, transactionObject] [, defaultBlock] [, callback]);
// Explicitly sending a transaction to this method
myContractInstance.myMethod.sendTransaction(param1 [, param2, ...] [, transactionObject] [, callback]);
// Get the call data, so you can call the contract through some other means
var myCallData = myContractInstance.myMethod.getData(param1 [, param2, ...]);
// myCallData = '0x45ff3ff6000000000004545345345345..'
複製代碼
合約對象內封裝了使用合約的相關方法。能夠經過傳入參數，和交易對象來使用方法。
參數：
String|Number- （可選）零或多個函數參數。若是傳入一個字符串，須要使用十六進制編碼，如，0xdedbeef。Object- （可選）最後一個參數（若是傳了callback，則是倒數第二個參數），能夠是一個交易對象。查看web3.eth.sendTransaction的第一個參數說明來了解更多。注意，這裏不須要填data和to屬性。Number|String-（可選）若是不設置此值使用web3.eth.defaultBlock設定的塊，不然使用指定的塊。Function-（可選）回調函數，用於支持異步的方式執行7。
返回值：
String - 若是發起的是一個call，對應的是返回結果。若是是transaction，則要麼是一個建立的合約地址，或者是一個transaction的哈希值。查看web3.eth.sendTransaction瞭解更多。
示例：
// creation of contract object
var MyContract = web3.eth.contract(abi);
// initiate contract for an address
var myContractInstance = MyContract.at('0x78e97bcc5b5dd9ed228fed7a4887c0d7287344a9');
var result = myContractInstance.myConstantMethod('myParam');
console.log(result) // '0x25434534534'
myContractInstance.myStateChangingMethod('someParam1', 23, {value: 200, gas: 2000}, function(err, result){ ... });
複製代碼
合約對象的事件
你能夠像web3.eth.filter這樣使用事件，他們有相同的方法，但須要傳遞不一樣的對象來建立事件過濾器。
參數：
Object- 你想返回的索引值（過濾哪些日誌）。如，{'valueA': 1, 'valueB': [myFirstAddress, mySecondAddress]}。默認狀況下，因此有過濾項被設置爲null。意味着默認匹配的是合約全部的日誌。Object- 附加的過濾選項。參見web3.eth.filter的第一個參數。默認狀況下，這個對象會設置address爲當前合約地址，同時第一個主題爲事件的簽名。Function-（可選）傳入一個回調函數，將當即開始監聽，這樣就不用主動調用myEvent.watch(function(){})7。
回調返回值：
Object - 事件對象，以下：
address:String，32字節- 日誌產生的合約地址。args:Object- 事件的參數。blockHash:String，32字節- 日誌所在塊的哈希。若是是pending的日誌，則爲null。blockNumber:Number- 日誌所在塊的塊號。若是是pending的日誌，則爲null。logIndex:Number- 日誌在區塊中的序號。若是是pending的日誌，則爲null。event:String- 事件名稱。removed:bool- 標識產生事件的這個交易是否被移除（由於孤塊），或從未生效（被拒絕的交易）。transactionIndex:Number- 產生日誌的交易在區塊中的序號。若是是pending的日誌，則爲null。transactionHash:String，32字節- 產生日誌的交易哈希值。
示例：
var MyContract = web3.eth.contract(abi);
var myContractInstance = MyContract.at('0x78e97bcc5b5dd9ed228fed7a4887c0d7287344a9');
// watch for an event with {some: 'args'}
var myEvent = myContractInstance.MyEvent({some: 'args'}, {fromBlock: 0, toBlock: 'latest'});
myEvent.watch(function(error, result){
...
});
// would get all past logs again.
var myResults = myEvent.get(function(error, logs){ ... });
...
// would stop and uninstall the filter
myEvent.stopWatching();
複製代碼
合約 allEvents
var events = myContractInstance.allEvents([additionalFilterObject]);
// watch for changes
events.watch(function(error, event){
if (!error)
console.log(event);
});
// Or pass a callback to start watching immediately
var events = myContractInstance.allEvents([additionalFilterObject,] function(error, log){
if (!error)
console.log(log);
});
複製代碼
調用合約建立的全部事件的回調。
參數：
Object- 附加的過濾選項。參見web3.eth.filter的第一個參數。默認狀況下，這個對象會設置address爲當前合約地址，同時第一個主題爲事件的簽名。Function-（可選）傳入一個回調函數，將當即開始監聽，這樣就不用主動調用myEvent.watch(function(){})7。
回調返回值：
Object - 詳見合約對象的事件瞭解更多。
示例：
var MyContract = web3.eth.contract(abi);
var myContractInstance = MyContract.at('0x78e97bcc5b5dd9ed228fed7a4887c0d7287344a9');
// watch for an event with {some: 'args'}
var events = myContractInstance.allEvents({fromBlock: 0, toBlock: 'latest'});
events.watch(function(error, result){
...
});
// would get all past logs again.
events.get(function(error, logs){ ... });
...
// would stop and uninstall the filter
myEvent.stopWatching();
複製代碼
web3.eth.getCompilers
web3.eth.getCompilers([callback])
返回可用的編譯器。
參數值：
Function-（可選）回調函數，用於支持異步的方式執行7。
返回值：
Array - 返回一個字符串數組，可用的編譯器。
web3.eth.compile.solidity
web3.eth.compile.solidity(sourceString [, callback])
編譯Solidity源代碼。
參數：
String- Solidity源代碼。Function-（可選）回調函數，用於支持異步的方式執行7。
返回值：
Object - 合約和編譯信息。
示例：
var source = "" +
"contract test {\n" +
" function multiply(uint a) returns(uint d) {\n" +
" return a * 7;\n" +
" }\n" +
"}\n";
var compiled = web3.eth.compile.solidity(source);
console.log(compiled);
// {
"test": {
"code": "0x605280600c6000396000f3006000357c010000000000000000000000000000000000000000000000000000000090048063c6888fa114602e57005b60376004356041565b8060005260206000f35b6000600782029050604d565b91905056",
"info": {
"source": "contract test {\n\tfunction multiply(uint a) returns(uint d) {\n\t\treturn a * 7;\n\t}\n}\n",
"language": "Solidity",
"languageVersion": "0",
"compilerVersion": "0.8.2",
"abiDefinition": [
{
"constant": false,
"inputs": [
{
"name": "a",
"type": "uint256"
}
],
"name": "multiply",
"outputs": [
{
"name": "d",
"type": "uint256"
}
],
"type": "function"
}
],
"userDoc": {
"methods": {}
},
"developerDoc": {
"methods": {}
}
}
}
}
複製代碼
web3.eth.compile.lll
web3. eth.compile.lll(sourceString [, callback])
編譯LLL源代碼。
參數：
String- LLL源代碼。Function-（可選）回調函數，用於支持異步的方式執行7。
返回值：
String - 十六進制格式編譯後的LLL編碼。
示例：
var source = "...";
var code = web3.eth.compile.lll(source);
console.log(code); // "0x603880600c6000396000f3006001600060e060020a600035048063c6888fa114601857005b6021600435602b565b8060005260206000f35b600081600702905091905056"
複製代碼
web3.eth.compile.serpent
web3.eth.compile.serpent(sourceString [, callback])
編譯serpent源代碼。
參數：
String- serpent源代碼。Function-（可選）回調函數，用於支持異步的方式執行7。
返回值：
String - 十六進制格式的編譯後的serpent編碼。
web3.eth.namereg
web3.eth.namereg
返回一個全球注意的對象。
使用方式：
查看這裏的例子：github.com/ethereum/we…
web3.db
web3.db.putString
web3.db.putString(db, key, value)
這個方法應當在咱們打算以一個本地數據庫的級別存儲一個字符串時使用。
參數：
String- 存儲使用的數據庫。String- 存儲的鍵。String- 存儲的值。
返回值：
Boolean - true表示成功，不然返回false。
示例：
web3.db.putString('testDB', 'key', 'myString') // true
複製代碼
web3.db.getString
web3.db.getString(db, key)
從本地的leveldb數據庫中返回一個字符串。
參數：
String- 存儲使用的數據庫。String- 存儲的鍵。
返回值：
String - 存儲的值。
示例：
var value = web3.db.getString('testDB', 'key');
console.log(value); // "myString"
複製代碼
web3.db.putHex
web3.db.putHex(db, key, value)
在本地的leveldb中存儲二進制數據。
參數：
String- 存儲使用的數據庫。String- 存儲的鍵。String- 十六進制格式的二進制。
返回值：
Boolean - 成功返回true，失敗返回false。
示例：
web3.db.putHex('testDB', 'key', '0x4f554b443'); // true
複製代碼
web3.db.getHex
web3.db.getHex(db, key)
返回本地的leveldb中的二進制數據。
參數：
String- 存儲使用的數據庫。String- 存儲的鍵。
返回值：
String - 存儲的十六進制值。
示例：
var value = web3.db.getHex('testDB', 'key');
console.log(value); // "0x4f554b443"
複製代碼
5. 參考文檔
1] Web3 JavaScript app API英文官網接口文檔 2] Web3 JavaScript Ðapp API 3] WEB3.JS代碼 4] WEB3的中文幫助文檔地址 5] 以太坊DApp開發入門教程——區塊鏈投票系統 - 匯智網 6] Web3與智能合約交互實戰 - 熊麗兵
- 1. 實例分析：寵物商店
- 2. 第二十六課 如何從零開始搭建一個Truffle框架的DAPP應用
- 3. 開發、部署去中心化應用(Dapp) - 寵物商店
- 4. 第七課 技術小白如何開發一個DAPP區塊鏈應用(以寵物商店爲例)
- 5. 第二十三課 如何部署TRUFFLE智能合約到以太坊主網(以寵物商店爲例)
- 6. 以太坊DApp開發:web3.js與智能合約交互
- 7. 從.NET的寵物商店到Android MVC MVP
- 8. 寵物商店信息管理系統
- 9. 寵物商店(pet-shop) 學習筆記
- 10. 動態網頁項目寵物商店
- 更多相關文章...
- • Docker 架構 - Docker教程
- • Git 查看提交歷史 - Git 教程
- • 算法總結-滑動窗口
- • RxJava操作符（十）自定義操作符
-
每一个你不满意的现在，都有一个你没有努力的曾经。