web3.js - 이더리움 자바스크립트 API¶

Web3.js는 로컬 환경 또는 원격 환경의 이더리움 노드와 HTTP 또는 IPC 를 사용해서 인터렉션 할 수 있게 도와주는 라이브러리입니다. 이 문서에서는 web3.js 실행과 설치하기 과정을 안내하고, API 레퍼런스를 다양한 예제와 함께 제공합니다.

색인, 검색

Getting Started¶

web3.js 라이브러리는 이더리움 환경에서 사용할수 있는 여러 기능을 모듈화 해놓은 라이브러리 입니다.

web3-eth 는 이더리움 블록체인과 스마트 컨트렉트를 위한 것 입니다.
web3-shh 는 p2p 통신을 하기위한 위스퍼 프로토콜 (whisper protocol)을 위한 것 입니다.
web3-bzz 는 탈중앙화된 파일 저장을 위한 스왐 프로토콜(swarm protocol) 을 위한 것 입니다
web3-utils 는 Dapp 개발자를 위한 많은 종류에 유용한 기능을 포함하고 있습니다.

web3.js 추가하기¶

먼저, web3.js 를 프로젝트에 임포트 해야합니다. 그것은 밑에 있는 방법들을 사용해서 할 수 있습니다. - npm: npm install web3 - yarn: yarn add web3 - pure js: link the dist/web3.min.js

그리고, web3 인스턴스를 만듬과 동시에 web3 provider 를 설정해야합니다. 이더리움을 지원 하는 브라우저 (Mist / MetaMask)는 ethereumProvider 또는 web3.currentProvider``를 사용할 수 있습니다. web3.js에서 사용할 수 있는 것은 ``web3.givenProvider 가 있습니다. 만약 property 가 null 이라면, 원격/로컬 노드에 연결해야만 합니다.

// node.js 에서 사용할 때 : var Web3 = require('web3');

var web3 = new Web3(Web3.givenProvider || "ws://localhost:8545");

끝입니다! 이제 web3 오브젝트를 사용할 수 있습니다 !!

Callbacks Promises Events¶

이 문서에서는 각자 다른 표준을 가진 모든 유형의 프로젝트에서의 Web3 도입을 위해, 비동기 함수로써 역할을 하는 다양한 방법을 제공합니다.

대부분의 Web3.js 오브젝트들은 마지막 파라미터를 콜백으로써 사용하는것 뿐만 아니라 promises 를 체인함수(chain functions) 에게 반환 할 수 있습니다.

블록체인으로써 이더리움은 다른 단계의 완결성(finality) 를 가지고 있기 때문에 여러 단계(stage)의 행위를 반환해야 합니다

이러한 요구사항에 대처하기 위해, "web3.eth.sendTransaction" 또는 Contract 메소드와 같은 기능에 대해서 "promiEvent"를 반환합니다.

이 "promiEvent" 는 promise와 결합된 이벤트 이미터(event emitter)가 트렌젝션과 같이 블록체인에서의 다른 단계(stage)의 행동을 하는것을 가능하게 하기 위한것입니다.

PromiEvent 는 일반적인 on, once and off 함수가 추가된 promise 처럼 작동합니다. 이 방법으로 개발자는, "영수증" 이나 "트렌젝션 해시" 와 같은 추가적인 이벤트를 볼 수 있습니다.

web3.eth.sendTransaction({from: '0x123...', data: '0x432...'})
.once('transactionHash', function(hash){ ... })
.once('receipt', function(receipt){ ... })
.on('confirmation', function(confNumber, receipt){ ... })
.on('error', function(error){ ... })
.then(function(receipt){
    // TransactionReceipt 가 발행되면 종료됩니다
});

Glossary¶

json 인터페이스¶

json 인터페이스는 json 오브젝트는 이더리움 스마트 계약을 위한 애플리케이션 바이너리 인터페이스(ABI) https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI를 기술합니다. web3.js 에서 json 인터페이스를 사용하기 위해서는, 스마트 컨트렉트에 대한 오브젝트(web3.eth.Contract object)와, 이에 대한 Method 와 Event 가 필요합니다 ------- 상세 -------

Functions:

type: "function", "constructor" (생략가능, ``"fallback"``도 가능합니다)중 선택 가능합니다.;
name: 함수의 이름입니다. (함수 타입에만 해당);
constant: 블록체인에서 상태를 변경하지 않을때 true 입니다.;
payable: 함수에서 이더리움을 받거나 보낼 수 있을때는 true ,기본적으로는 false 입니다.;
stateMutability: a string with one of the following values: pure (specified to not read blockchain state), view (same as constant above), nonpayable and payable (same as payable above);
inputs: 오브젝트의 배열입니다, 각각의 요소는: - name: 파라미터의 이름입니다; - type: 파라미터의 타입입니다;
outputs: ``inputs``과 동일한 오브젝트의 배열입니다, 출력이 없을경우 생략이 가능합니다.

Events:

type: 항상 "event" 입니다;
name: event의 이름입니다;
inputs: - name: 파라미터의 이름입니다; - type: 파라미터의 타입입니다; - indexed: true 일때는 필드가 로그 주제의 일부인 경우이고, false 일때는 로그의 데이터 세그먼트일 때 입니다.
anonymous: 익명(anonymous)으로 선언되어있을때 true 입니다.

예제¶

contract Test {
    uint a;
    address d = 0x12345678901234567890123456789012;

    function Test(uint testInt)  { a = testInt;}

    event Event(uint indexed b, bytes32 c);

    event Event2(uint indexed b, bytes32 c);

    function foo(uint b, bytes32 c) returns(address) {
        Event(b, c);
        return d;
    }
}

// JSON 결과값
[{
    "type":"constructor",
    "payable":false,
    "stateMutability":"nonpayable"
    "inputs":[{"name":"testInt","type":"uint256"}],
  },{
    "type":"function",
    "name":"foo",
    "constant":false,
    "payable":false,
    "stateMutability":"nonpayable",
    "inputs":[{"name":"b","type":"uint256"}, {"name":"c","type":"bytes32"}],
    "outputs":[{"name":"","type":"address"}]
  },{
    "type":"event",
    "name":"Event",
    "inputs":[{"indexed":true,"name":"b","type":"uint256"}, {"indexed":false,"name":"c","type":"bytes32"}],
    "anonymous":false
  },{
    "type":"event",
    "name":"Event2",
    "inputs":[{"indexed":true,"name":"b","type":"uint256"},{"indexed":false,"name":"c","type":"bytes32"}],
    "anonymous":false
}]

Web3¶

이것은 web3.js 라이브러리의 메인(또는 'umbrella') 클래스 입니다.

var Web3 = require('web3');
> Web3.utils
> Web3.version
> Web3.givenProvider
> Web3.providers
> Web3.modules

Web3.modules¶

   Web3.modules

object 를 수동으로 인스턴스화 가능하게 object 를 모든 주요 sub modules 의 classes 와 함께 return 합니다.

이것은 모든 주요 하위 모듈의 클래스와 함께 객체를 반환하여 수동으로 인스턴스화 할 수 있게 해줍니다.¶

반환값¶

Object: Module Constructor 에 대한 리스트

Eth - Constructor: Eth 모듈은 이더리움 네트워크와 통신하는 모듈입니다. web3.eth 에서 자세한 정보를 확인 할 수 있습니다.
Net - Constructor: Net 모듈은 네트워크 속성과 관련된 모듈입니다. web3.eth.net 에서 자세한 정보를 확인 할 수 있습니다.
Personal - Constructor: Personal 모듈은 이더리움 계정과 관련된 처리를 하는 모듈입니다. web3.eth.personal 에서 자세한 정보를 확인 할 수 있습니다.
Shh - Constructor: Shh 모듈은 Whisper 프로토콜과 관련된 처리를 하는 모듈입니다. web3.shh 에서 자세한 정보를 확인 할 수 있습니다.
Bzz - Constructor: Bzz 모듈은 Swarm 네트워크와 관련된 처리를 하는 모듈입니다. web3.bzz 에서 자세한 정보를 확인 할 수 있습니다.

예제¶

Web3.modules
> {
    Eth: Eth(provider),
    Net: Net(provider),
    Personal: Personal(provider),
    Shh: Shh(provider),
    Bzz: Bzz(provider),
}

Web3 인스터스 (Instance)¶

Web3 class 는 모든 Ethereum 관련 modules 를 담을 수 있는 umbrella package 입니다.

var Web3 = require('web3');

//"Web3.providers.givenProvider" 는 이더리움 지원 브라우저에 대해 설정 됩니다.

==

var web3 = new Web3(Web3.givenProvider || 'ws://some.local-or-remote.node:8546');

> web3.eth > web3.shh > web3.bzz > web3.utils > web3.version

version¶

Web3 클래스의 정적 액세스(Static Access) 가능한 속성과 인스턴스별 속성 입니다.

Web3.version
web3.version

web3.js 라이브러리의 현재 패키지 버전을 포함합니다.

String: 현재의 버전 정보

web3.version;
> "1.2.3"

utils(유틸)¶

Web3 클래스의 정적 액세스(Static Access) 가능한 속성과 인스턴스별 속성 입니다.

Web3.utils
web3.utils

유틸리티 함수는 Web3 클래스 객체에 직접적으로 노출 됩니다. 자세한 정보는 :ref:`web3.utils <utils>`에서 확인 할 수 있습니다.

setProvider¶

web3.setProvider(myProvider)
web3.eth.setProvider(myProvider)
web3.shh.setProvider(myProvider)
web3.bzz.setProvider(myProvider)
...

해당 모듈의 web3 Provider를 변경 또는 설정 합니다. .. note:: web3.eth, web3.shh 등등과 같은 모든 하위 모듈에 대해 동일한 Provider가 설정됩니다. web3.bzz 는 분리된 provider가 예외적으로 적용됩니다.

Object - myProvider: :ref:Provider를 검증합니다. <web3-providers>.

Boolean

var Web3 = require('web3');
var web3 = new Web3('http://localhost:8545');
// 또는
var web3 = new Web3(new Web3.providers.HttpProvider('http://localhost:8545'));

// provider를 변경합니다.
web3.setProvider('ws://localhost:8546');

// 또는

web3.setProvider(new Web3.providers.WebsocketProvider('ws://localhost:8546'));

// node.js 에서 IPC Provider를 사용합니다.
var net = require('net');
var web3 = new Web3('/Users/myuser/Library/Ethereum/geth.ipc', net); // mac os 의 경로

// 또는

var web3 = new Web3(new Web3.providers.IpcProvider('/Users/myuser/Library/Ethereum/geth.ipc', net)); // mac os 경로
// 윈도우의 경로 : "\\\\.\\pipe\\geth.ipc"
// 리눅스의 경로: "/users/myuser/.ethereum/geth.ipc"

providers(프로바이더)¶

web3.providers
web3.eth.providers
web3.shh.providers
web3.bzz.providers
...

providers 를 포함하고 있습니다.¶

반환값 (Return)¶

Object with the following providers:

Object - HttpProvider:http 프로바이더는 더이상 사용되지 않게 되었습니다. 이것은 구독에 사용할 수 없을 것 입니다.

Object - WebsocketProvider: 웹 소켓 프로바이더는 레거시 브라우저에 대한 표준입니다.

Object - IpcProvider: IPC 프로바이더는 로컬노드를 사용하는 nodejs Dapp에 대한 표준입니다. 가장 안전한 연결을 제공합니다.

예시 (예시 (Example))¶

var Web3 = require('web3');
// use the given Provider, e.g in Mist, or instantiate a new websocket provider
//
var web3 = new Web3(Web3.givenProvider || 'ws://remotenode.com:8546');
// or
var web3 = new Web3(Web3.givenProvider || new Web3.providers.WebsocketProvider('ws://remotenode.com:8546'));

// Using the IPC provider in node.js
var net = require('net');

var web3 = new Web3('/Users/myuser/Library/Ethereum/geth.ipc', net); // mac os path
// or
var web3 = new Web3(new Web3.providers.IpcProvider('/Users/myuser/Library/Ethereum/geth.ipc', net)); // mac os path
// on windows the path is: "\\\\.\\pipe\\geth.ipc"
// on linux the path is: "/users/myuser/.ethereum/geth.ipc"

설정하기¶

// ====
// Http
// ====

var Web3HttpProvider = require('web3-providers-http');

var options = {
    keepAlive: true,
    withCredentials: false,
    timeout: 20000, // ms
    headers: [
        {
            name: 'Access-Control-Allow-Origin',
            value: '*'
        },
        {
            ...
        }
    ],
    agent: {
        http: http.Agent(...),
        baseUrl: ''
    }
};

var provider = new Web3HttpProvider('http://localhost:8545', options);

// ==========
// 웹소켓
// ==========

var Web3WsProvider = require('web3-providers-ws');

var options = {
    timeout: 30000, // ms

    // 크레덴셜을 url에 포함해서 사용할 수 있습니다 ex: ws://username:password@localhost:8546
    headers: {
      authorization: 'Basic username:password'
    },

    // 만약 결과값이 크다면 사용할 수 있습니다.
    clientConfig: {
      maxReceivedFrameSize: 100000000,   // bytes - default: 1MiB
      maxReceivedMessageSize: 100000000, // bytes - default: 8MiB
    },

    // 자동 재연결 활성화
    reconnect: {
        auto: true,
        delay: 5000, // ms
        maxAttempts: 5,
        onTimeout: false
    }
};

var ws = new Web3WsProvider('ws://localhost:8546', options);

HTTP 와 Websocket 프로바이더에 대한 정보를 더 얻으려면 밑에 링크를 참고할 수 있습니다.

givenProvider¶

web3.givenProvider
web3.eth.
web3.shh.givenProvider
web3.bzz.givenProvider
...

이더리움 호환 브라우저에서 web3.js 를 사용하면, 이 함수는 해당 브라우저의 네이티브 프로바이더를 반환합니다. 호환 브라우저가 아닐 경우, null 을 반환합니다.

Object: 설정된 givenProvider 또는 null.;

currentProvider¶

web3.currentProvider
web3.eth.currentProvider
web3.shh.currentProvider
web3.bzz.currentProvider
...

현재 provider 또는 null 을 반환합니다

Object: 현재 설정된 프로바이더 또는 null;

BatchRequest¶

new web3.BatchRequest()
new web3.eth.BatchRequest()
new web3.shh.BatchRequest()
new web3.bzz.BatchRequest()

Batch 요청을 만들고 실행하는 클래스 입니다.¶

인자 (Parameters)¶

없음

반환값 (Returns)¶

Object: 밑에 두 메소드로 이루어져 있습니다:

add(request): batch call에 요청 오브젝트를 추가합니다.

execute(): batch 요청을 실행합니다.

예시 (Example)¶

var contract = new web3.eth.Contract(abi, address);

var batch = new web3.BatchRequest();
batch.add(web3.eth.getBalance.request('0x0000000000000000000000000000000000000000', 'latest', callback));
batch.add(contract.methods.balance(address).call.request({from: '0x0000000000000000000000000000000000000000'}, callback2));
batch.execute();

extend¶

web3.extend(methods)
web3.eth.extend(methods)
web3.shh.extend(methods)
web3.bzz.extend(methods)
...

web3 모듈을 확장할 수 있게 합니다.

methods - Object: 메서드 배열이 있는 확장 개체에서는 개체를 아래와 같이 설명한다:
- property - String: (optional) 모듈에 추가할 속성의 이름. 설정된 속성이 없는 경우 모듈에 직접 추가됨.
- methods - Array: 메서드 설명 배열
  
  name - String: 추가할 메서드의 이름.
  
  call - String: RPC 메서드의 이름.
  
  params - Number: (optional) 함수에 대한 파라미터의 갯수, 기본값은 0.
  
  inputFormatter - Array: (optional) 입력 포맷터 함수 배열. 각 어레이 항목은 함수 매개 변수에 응답하므로 일부 매개 변수를 포맷하지 않으려면 대신 null 을 추가하세요.
  
  outputFormatter - ``Function: (optional) 메서드의 출력을 포맷하는 데 사용할 수 있다.

Object: 확장 모듈을 반환합니다.

web3.extend({
    property: 'myModule',
    methods: [{
        name: 'getBalance',
        call: 'eth_getBalance',
        params: 2,
        inputFormatter: [web3.extend.formatters.inputAddressFormatter, web3.extend.formatters.inputDefaultBlockNumberFormatter],
        outputFormatter: web3.utils.hexToNumberString
    },{
        name: 'getGasPriceSuperFunction',
        call: 'eth_gasPriceSuper',
        params: 2,
        inputFormatter: [null, web3.utils.numberToHex]
    }]
});

web3.extend({
    methods: [{
        name: 'directCall',
        call: 'eth_callForFun',
    }]
});

console.log(web3);
> Web3 {
    myModule: {
        getBalance: function(){},
        getGasPriceSuperFunction: function(){}
    },
    directCall: function(){},
    eth: Eth {...},
    bzz: Bzz {...},
    ...
}

web3.eth¶

The web3-eth package allows you to interact with an Ethereum blockchain and Ethereum smart contracts.

var Eth = require('web3-eth');

// "Eth.providers.givenProvider" will be set if in an Ethereum supported browser.
var eth = new Eth(Eth.givenProvider || 'ws://some.local-or-remote.node:8546');

// or using the web3 umbrella package

var Web3 = require('web3');
var web3 = new Web3(Web3.givenProvider || 'ws://some.local-or-remote.node:8546');

// -> web3.eth

Note on checksum addresses¶

All Ethereum addresses returned by functions of this package are returned as checksum addresses. This means some letters are uppercase and some are lowercase. Based on that it will calculate a checksum for the address and prove its correctness. Incorrect checksum addresses will throw an error when passed into functions. If you want to circumvent the checksum check you can make an address all lower- or uppercase.

Example¶

web3.eth.getAccounts(console.log);
> ["0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe" ,"0x85F43D8a49eeB85d32Cf465507DD71d507100C1d"]

setProvider¶

web3.setProvider(myProvider)
web3.eth.setProvider(myProvider)
web3.shh.setProvider(myProvider)
web3.bzz.setProvider(myProvider)
...

해당 모듈의 web3 Provider를 변경 또는 설정 합니다. .. note:: web3.eth, web3.shh 등등과 같은 모든 하위 모듈에 대해 동일한 Provider가 설정됩니다. web3.bzz 는 분리된 provider가 예외적으로 적용됩니다.

매개변수(Parameters)¶

Object - myProvider: :ref:Provider를 검증합니다. <web3-providers>.

반환값 (Return)¶

Boolean

예시 (예시 (Example))¶

var Web3 = require('web3');
var web3 = new Web3('http://localhost:8545');
// 또는
var web3 = new Web3(new Web3.providers.HttpProvider('http://localhost:8545'));

// provider를 변경합니다.
web3.setProvider('ws://localhost:8546');

// 또는

web3.setProvider(new Web3.providers.WebsocketProvider('ws://localhost:8546'));

// node.js 에서 IPC Provider를 사용합니다.
var net = require('net');
var web3 = new Web3('/Users/myuser/Library/Ethereum/geth.ipc', net); // mac os 의 경로

// 또는

var web3 = new Web3(new Web3.providers.IpcProvider('/Users/myuser/Library/Ethereum/geth.ipc', net)); // mac os 경로
// 윈도우의 경로 : "\\\\.\\pipe\\geth.ipc"
// 리눅스의 경로: "/users/myuser/.ethereum/geth.ipc"

providers(프로바이더)¶

web3.providers
web3.eth.providers
web3.shh.providers
web3.bzz.providers
...

Object with the following providers:

Object - HttpProvider:http 프로바이더는 더이상 사용되지 않게 되었습니다. 이것은 구독에 사용할 수 없을 것 입니다.

Object - WebsocketProvider: 웹 소켓 프로바이더는 레거시 브라우저에 대한 표준입니다.

Object - IpcProvider: IPC 프로바이더는 로컬노드를 사용하는 nodejs Dapp에 대한 표준입니다. 가장 안전한 연결을 제공합니다.

예시 (예시 (Example))¶

var Web3 = require('web3');
// use the given Provider, e.g in Mist, or instantiate a new websocket provider
//
var web3 = new Web3(Web3.givenProvider || 'ws://remotenode.com:8546');
// or
var web3 = new Web3(Web3.givenProvider || new Web3.providers.WebsocketProvider('ws://remotenode.com:8546'));

// Using the IPC provider in node.js
var net = require('net');

var web3 = new Web3('/Users/myuser/Library/Ethereum/geth.ipc', net); // mac os path
// or
var web3 = new Web3(new Web3.providers.IpcProvider('/Users/myuser/Library/Ethereum/geth.ipc', net)); // mac os path
// on windows the path is: "\\\\.\\pipe\\geth.ipc"
// on linux the path is: "/users/myuser/.ethereum/geth.ipc"

설정하기¶

// ====
// Http
// ====

var Web3HttpProvider = require('web3-providers-http');

var options = {
    keepAlive: true,
    withCredentials: false,
    timeout: 20000, // ms
    headers: [
        {
            name: 'Access-Control-Allow-Origin',
            value: '*'
        },
        {
            ...
        }
    ],
    agent: {
        http: http.Agent(...),
        baseUrl: ''
    }
};

var provider = new Web3HttpProvider('http://localhost:8545', options);

// ==========
// 웹소켓
// ==========

var Web3WsProvider = require('web3-providers-ws');

var options = {
    timeout: 30000, // ms

    // 크레덴셜을 url에 포함해서 사용할 수 있습니다 ex: ws://username:password@localhost:8546
    headers: {
      authorization: 'Basic username:password'
    },

    // 만약 결과값이 크다면 사용할 수 있습니다.
    clientConfig: {
      maxReceivedFrameSize: 100000000,   // bytes - default: 1MiB
      maxReceivedMessageSize: 100000000, // bytes - default: 8MiB
    },

    // 자동 재연결 활성화
    reconnect: {
        auto: true,
        delay: 5000, // ms
        maxAttempts: 5,
        onTimeout: false
    }
};

var ws = new Web3WsProvider('ws://localhost:8546', options);

HTTP 와 Websocket 프로바이더에 대한 정보를 더 얻으려면 밑에 링크를 참고할 수 있습니다.

givenProvider¶

web3.givenProvider
web3.eth.
web3.shh.givenProvider
web3.bzz.givenProvider
...

이더리움 호환 브라우저에서 web3.js 를 사용하면, 이 함수는 해당 브라우저의 네이티브 프로바이더를 반환합니다. 호환 브라우저가 아닐 경우, null 을 반환합니다.

반환값 (Returns)¶

Object: 설정된 givenProvider 또는 null.;

예시 (Example)¶

currentProvider¶

web3.currentProvider
web3.eth.currentProvider
web3.shh.currentProvider
web3.bzz.currentProvider
...

현재 provider 또는 null 을 반환합니다

반환값 (Returns)¶

Object: 현재 설정된 프로바이더 또는 null;

예시 (Example)¶

BatchRequest¶

new web3.BatchRequest()
new web3.eth.BatchRequest()
new web3.shh.BatchRequest()
new web3.bzz.BatchRequest()

없음

반환값 (Returns)¶

Object: 밑에 두 메소드로 이루어져 있습니다:

add(request): batch call에 요청 오브젝트를 추가합니다.

execute(): batch 요청을 실행합니다.

예시 (Example)¶

var contract = new web3.eth.Contract(abi, address);

var batch = new web3.BatchRequest();
batch.add(web3.eth.getBalance.request('0x0000000000000000000000000000000000000000', 'latest', callback));
batch.add(contract.methods.balance(address).call.request({from: '0x0000000000000000000000000000000000000000'}, callback2));
batch.execute();

extend¶

web3.extend(methods)
web3.eth.extend(methods)
web3.shh.extend(methods)
web3.bzz.extend(methods)
...

web3 모듈을 확장할 수 있게 합니다.

인자¶

methods - Object: 메서드 배열이 있는 확장 개체에서는 개체를 아래와 같이 설명한다:
- property - String: (optional) 모듈에 추가할 속성의 이름. 설정된 속성이 없는 경우 모듈에 직접 추가됨.
- methods - Array: 메서드 설명 배열
  
  name - String: 추가할 메서드의 이름.
  
  call - String: RPC 메서드의 이름.
  
  params - Number: (optional) 함수에 대한 파라미터의 갯수, 기본값은 0.
  
  inputFormatter - Array: (optional) 입력 포맷터 함수 배열. 각 어레이 항목은 함수 매개 변수에 응답하므로 일부 매개 변수를 포맷하지 않으려면 대신 null 을 추가하세요.
  
  outputFormatter - ``Function: (optional) 메서드의 출력을 포맷하는 데 사용할 수 있다.

반환값 (Returns)¶

Object: 확장 모듈을 반환합니다.

예시 (Example)¶

web3.extend({
    property: 'myModule',
    methods: [{
        name: 'getBalance',
        call: 'eth_getBalance',
        params: 2,
        inputFormatter: [web3.extend.formatters.inputAddressFormatter, web3.extend.formatters.inputDefaultBlockNumberFormatter],
        outputFormatter: web3.utils.hexToNumberString
    },{
        name: 'getGasPriceSuperFunction',
        call: 'eth_gasPriceSuper',
        params: 2,
        inputFormatter: [null, web3.utils.numberToHex]
    }]
});

web3.extend({
    methods: [{
        name: 'directCall',
        call: 'eth_callForFun',
    }]
});

console.log(web3);
> Web3 {
    myModule: {
        getBalance: function(){},
        getGasPriceSuperFunction: function(){}
    },
    directCall: function(){},
    eth: Eth {...},
    bzz: Bzz {...},
    ...
}

defaultAccount¶

web3.eth.defaultAccount

This default address is used as the default "from" property, if no "from" property is specified in for the following methods:

web3.eth.sendTransaction()
web3.eth.call()
new web3.eth.Contract() -> myContract.methods.myMethod().call()
new web3.eth.Contract() -> myContract.methods.myMethod().send()

Property¶

String - 20 Bytes: Any ethereum address. You should have the private key for that address in your node or keystore. (Default is undefined)

Example¶

web3.eth.defaultAccount;
> undefined

// set the default account
web3.eth.defaultAccount = '0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe';

defaultBlock¶

web3.eth.defaultBlock

The default block is used for certain methods. You can override it by passing in the defaultBlock as last parameter. The default value is "latest".

web3.eth.getBalance()
web3.eth.getCode()
web3.eth.getTransactionCount()
web3.eth.getStorageAt()
web3.eth.call()
new web3.eth.Contract() -> myContract.methods.myMethod().call()

Property¶

Default block parameters can be one of the following:

Number|BN|BigNumber: A block number
"genesis" - String: The genesis block
"latest" - String: The latest block (current head of the blockchain)
"pending" - String: The currently mined block (including pending transactions)
"earliest" - String: The genesis block

Default is "latest"

Example¶

web3.eth.defaultBlock;
> "latest"

// set the default block
web3.eth.defaultBlock = 231;

defaultHardfork¶

web3.eth.defaultHardfork

The default hardfork property is used for signing transactions locally.

Property¶

The default hardfork property can be one of the following:

"chainstart" - String
"homestead" - String
"dao" - String
"tangerineWhistle" - String
"spuriousDragon" - String
"byzantium" - String
"constantinople" - String
"petersburg" - String
"istanbul" - String

Default is "petersburg"

Example¶

web3.eth.defaultHardfork;
> "petersburg"

// set the default block
web3.eth.defaultHardfork = 'istanbul';

defaultChain¶

web3.eth.defaultChain

The default chain property is used for signing transactions locally.

Property¶

The default chain property can be one of the following:

"mainnet" - String
"goerli" - String
"kovan" - String
"rinkeby" - String
"ropsten" - String

Default is "mainnet"

Example¶

web3.eth.defaultChain;
> "mainnet"

// set the default chain
web3.eth.defaultChain = 'goerli';

defaultCommon¶

web3.eth.defaultCommon

The default common property is used for signing transactions locally.

Property¶

The default common property does contain the following Common object:

customChain - Object: The custom chain properties
- name - string: (optional) The name of the chain
- networkId - number: Network ID of the custom chain
- chainId - number: Chain ID of the custom chain
baseChain - string: (optional) mainnet, goerli, kovan, rinkeby, or ropsten
hardfork - string: (optional) chainstart, homestead, dao, tangerineWhistle, spuriousDragon, byzantium, constantinople, petersburg, or istanbul

Default is undefined.

Example¶

web3.eth.defaultCommon;
> {customChain: {name: 'custom-network', chainId: 1, networkId: 1}, baseChain: 'mainnet', hardfork: 'petersburg'}

// set the default common
web3.eth.defaultCommon = {customChain: {name: 'custom-network', chainId: 1, networkId: 1}, baseChain: 'mainnet', hardfork: 'petersburg'};

transactionBlockTimeout¶

web3.eth.transactionBlockTimeout

The transactionBlockTimeout will be used over a socket based connection. This option does define the amount of new blocks it should wait until the first confirmation happens. This means the PromiEvent rejects with a timeout error when the timeout got exceeded.

Returns¶

number: The current value of transactionBlockTimeout (default: 50)

transactionConfirmationBlocks¶

web3.eth.transactionConfirmationBlocks

This defines the number of blocks it requires until a transaction will be handled as confirmed.

Returns¶

number: The current value of transactionConfirmationBlocks (default: 24)

transactionPollingTimeout¶

web3.eth.transactionPollingTimeout

The transactionPollingTimeout will be used over a HTTP connection. This option defines the number of seconds Web3 will wait for a receipt which confirms that a transaction was mined by the network. NB: If this method times out, the transaction may still be pending.

Returns¶

number: The current value of transactionPollingTimeout (default: 750)

handleRevert¶

web3.eth.handleRevert

The handleRevert options property does default to false and will return the revert reason string if enabled for the following methods:

web3.eth.call()
web3.eth.sendTransaction()
contract.methods.myMethod(...).send(...)
contract.methods.myMethod(...).call(...)

주석

The revert reason string and the signature does exist as property on the returned error.

Returns¶

boolean: The current value of handleRevert (default: false)

getProtocolVersion¶

web3.eth.getProtocolVersion([callback])

Returns the ethereum protocol version of the node.

Returns¶

Promise returns String: the protocol version.

Example¶

web3.eth.getProtocolVersion()
.then(console.log);
> "63"

isSyncing¶

web3.eth.isSyncing([callback])

Checks if the node is currently syncing and returns either a syncing object, or false.

Returns¶

Promise returns Object|Boolean - A sync object when the node is currently syncing or false:

startingBlock - Number: The block number where the sync started.

currentBlock - Number: The block number where at which block the node currently synced to already.

highestBlock - Number: The estimated block number to sync to.

knownStates - Number: The estimated states to download

pulledStates - Number: The already downloaded states

Example¶

web3.eth.isSyncing()
.then(console.log);

> {
    startingBlock: 100,
    currentBlock: 312,
    highestBlock: 512,
    knownStates: 234566,
    pulledStates: 123455
}

getCoinbase¶

getCoinbase([callback])

Returns the coinbase address to which mining rewards will go.

Returns¶

Promise returns String - bytes 20: The coinbase address set in the node for mining rewards.

Example¶

web3.eth.getCoinbase()
.then(console.log);
> "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe"

isMining¶

web3.eth.isMining([callback])

Checks whether the node is mining or not.

Returns¶

Promise returns Boolean: true if the node is mining, otherwise false.

Example¶

web3.eth.isMining()
.then(console.log);
> true

getHashrate¶

web3.eth.getHashrate([callback])

Returns the number of hashes per second that the node is mining with.

Returns¶

Promise returns Number: Number of hashes per second.

Example¶

web3.eth.getHashrate()
.then(console.log);
> 493736

getGasPrice¶

web3.eth.getGasPrice([callback])

Returns the current gas price oracle. The gas price is determined by the last few blocks median gas price.

Returns¶

Promise returns String - Number string of the current gas price in wei.

See the A note on dealing with big numbers in JavaScript.

Example¶

web3.eth.getGasPrice()
.then(console.log);
> "20000000000"

getAccounts¶

web3.eth.getAccounts([callback])

Returns a list of accounts the node controls.

Returns¶

Promise returns Array - An array of addresses controlled by node.

Example¶

web3.eth.getAccounts()
.then(console.log);
> ["0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe", "0xDCc6960376d6C6dEa93647383FfB245CfCed97Cf"]

getBlockNumber¶

web3.eth.getBlockNumber([callback])

Returns the current block number.

Returns¶

Promise returns Number - The number of the most recent block.

Example¶

web3.eth.getBlockNumber()
.then(console.log);
> 2744

getBalance¶

web3.eth.getBalance(address [, defaultBlock] [, callback])

Get the balance of an address at a given block.

Parameters¶

String - The address to get the balance of.
Number|String|BN|BigNumber - (optional) If you pass this parameter it will not use the default block set with web3.eth.defaultBlock. Pre-defined block numbers as "latest", "earliest", "pending", and "genesis" can also be used.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns String - The current balance for the given address in wei.

See the A note on dealing with big numbers in JavaScript.

Example¶

web3.eth.getBalance("0x407d73d8a49eeb85d32cf465507dd71d507100c1")
.then(console.log);
> "1000000000000"

getStorageAt¶

web3.eth.getStorageAt(address, position [, defaultBlock] [, callback])

Get the storage at a specific position of an address.

Parameters¶

String - The address to get the storage from.
Number|String|BN|BigNumber - The index position of the storage.
Number|String|BN|BigNumber - (optional) If you pass this parameter it will not use the default block set with web3.eth.defaultBlock. Pre-defined block numbers as "latest", "earliest", "pending", and "genesis" can also be used.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns String - The value in storage at the given position.

Example¶

web3.eth.getStorageAt("0x407d73d8a49eeb85d32cf465507dd71d507100c1", 0)
.then(console.log);
> "0x033456732123ffff2342342dd12342434324234234fd234fd23fd4f23d4234"

getCode¶

web3.eth.getCode(address [, defaultBlock] [, callback])

Get the code at a specific address.

Parameters¶

String - The address to get the code from.
Number|String|BN|BigNumber - (optional) If you pass this parameter it will not use the default block set with web3.eth.defaultBlock. Pre-defined block numbers as "latest", "earliest", "pending", and "genesis" can also be used.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns String - The data at given address address.

Example¶

web3.eth.getCode("0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8")
.then(console.log);
> "0x600160008035811a818181146012578301005b601b6001356025565b8060005260206000f25b600060078202905091905056"

getBlock¶

web3.eth.getBlock(blockHashOrBlockNumber [, returnTransactionObjects] [, callback])

Returns a block matching the block number or block hash.

Parameters¶

String|Number|BN|BigNumber - The block number or block hash. Or the string "genesis", "latest", "earliest", or "pending" as in the default block parameter.
Boolean - (optional, default false) If specified true, the returned block will contain all transactions as objects. By default it is false so, there is no need to explictly specify false. And, if false it will only contains the transaction hashes.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns Object - The block object:

number - Number: The block number. null when its pending block.

hash 32 Bytes - String: Hash of the block. null when its pending block.

parentHash 32 Bytes - String: Hash of the parent block.

nonce 8 Bytes - String: Hash of the generated proof-of-work. null when its pending block.

sha3Uncles 32 Bytes - String: SHA3 of the uncles data in the block.

logsBloom 256 Bytes - String: The bloom filter for the logs of the block. null when its pending block.

transactionsRoot 32 Bytes - String: The root of the transaction trie of the block

stateRoot 32 Bytes - String: The root of the final state trie of the block.

miner - String: The address of the beneficiary to whom the mining rewards were given.

difficulty - String: Integer of the difficulty for this block.

totalDifficulty - String: Integer of the total difficulty of the chain until this block.

extraData - String: The "extra data" field of this block.

size - Number: Integer the size of this block in bytes.

gasLimit - Number: The maximum gas allowed in this block.

gasUsed - Number: The total used gas by all transactions in this block.

timestamp - Number: The unix timestamp for when the block was collated.

transactions - Array: Array of transaction objects, or 32 Bytes transaction hashes depending on the returnTransactionObjects parameter.

uncles - Array: Array of uncle hashes.

Example¶

web3.eth.getBlock(3150)
.then(console.log);

> {
    "number": 3,
    "hash": "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46",
    "parentHash": "0x2302e1c0b972d00932deb5dab9eb2982f570597d9d42504c05d9c2147eaf9c88",
    "nonce": "0xfb6e1a62d119228b",
    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
    "transactionsRoot": "0x3a1b03875115b79539e5bd33fb00d8f7b7cd61929d5a3c574f507b8acf415bee",
    "stateRoot": "0xf1133199d44695dfa8fd1bcfe424d82854b5cebef75bddd7e40ea94cda515bcb",
    "miner": "0x8888f1f195afa192cfee860698584c030f4c9db1",
    "difficulty": '21345678965432',
    "totalDifficulty": '324567845321',
    "size": 616,
    "extraData": "0x",
    "gasLimit": 3141592,
    "gasUsed": 21662,
    "timestamp": 1429287689,
    "transactions": [
        "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b"
    ],
    "uncles": []
}

getBlockTransactionCount¶

web3.eth.getBlockTransactionCount(blockHashOrBlockNumber [, callback])

Returns the number of transaction in a given block.

Parameters¶

String|Number|BN|BigNumber - The block number or hash. Or the string "genesis", "latest", "earliest", or "pending" as in the default block parameter.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns Number - The number of transactions in the given block.

Example¶

web3.eth.getBlockTransactionCount("0x407d73d8a49eeb85d32cf465507dd71d507100c1")
.then(console.log);
> 1

getBlockUncleCount¶

web3.eth.getBlockUncleCount(blockHashOrBlockNumber [, callback])

Returns the number of uncles in a block from a block matching the given block hash.

Parameters¶

String|Number|BN|BigNumber - The block number or hash. Or the string "genesis", "latest", "earliest", or "pending" as in the default block parameter.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns Number - The number of transactions in the given block.

Example¶

web3.eth.getBlockUncleCount("0x407d73d8a49eeb85d32cf465507dd71d507100c1")
.then(console.log);
> 1

getUncle¶

web3.eth.getUncle(blockHashOrBlockNumber, uncleIndex [, returnTransactionObjects] [, callback])

Returns a blocks uncle by a given uncle index position.

Parameters¶

String|Number|BN|BigNumber - The block number or hash. Or the string "genesis", "latest", "earliest", or "pending" as in the default block parameter.
Number - The index position of the uncle.
Boolean - (optional, default false) If specified true, the returned block will contain all transactions as objects. By default it is false so, there is no need to explictly specify false. And, if false it will only contains the transaction hashes.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns Object - the returned uncle. For a return value see web3.eth.getBlock().

주석

An uncle doesn't contain individual transactions.

Example¶

web3.eth.getUncle(500, 0)
.then(console.log);
> // see web3.eth.getBlock

getTransaction¶

web3.eth.getTransaction(transactionHash [, callback])

Returns a transaction matching the given transaction hash.

Parameters¶

String - The transaction hash.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns Object - A transaction object its hash transactionHash:

hash 32 Bytes - String: Hash of the transaction.

nonce - Number: The number of transactions made by the sender prior to this one.

blockHash 32 Bytes - String: Hash of the block where this transaction was in. null when its pending.

blockNumber - Number: Block number where this transaction was in. null when its pending.

transactionIndex - Number: Integer of the transactions index position in the block. null when its pending.

from - String: Address of the sender.

to - String: Address of the receiver. null when its a contract creation transaction.

value - String: Value transferred in wei.

gasPrice - String: Gas price provided by the sender in wei.

gas - Number: Gas provided by the sender.

input - String: The data sent along with the transaction.

Example¶

web3.eth.getTransaction('0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b§234')
.then(console.log);

> {
    "hash": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b",
    "nonce": 2,
    "blockHash": "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46",
    "blockNumber": 3,
    "transactionIndex": 0,
    "from": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
    "to": "0x6295ee1b4f6dd65047762f924ecd367c17eabf8f",
    "value": '123450000000000000',
    "gas": 314159,
    "gasPrice": '2000000000000',
    "input": "0x57cb2fc4"
}

getPendingTransactions¶

web3.eth.getPendingTransactions([, callback])

Returns a list of pending transactions.

Parameters¶

Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise<object[]> - Array of pending transactions:

hash 32 Bytes - String: Hash of the transaction.

nonce - Number: The number of transactions made by the sender prior to this one.

blockHash 32 Bytes - String: Hash of the block where this transaction was in. null when its pending.

blockNumber - Number: Block number where this transaction was in. null when its pending.

transactionIndex - Number: Integer of the transactions index position in the block. null when its pending.

from - String: Address of the sender.

to - String: Address of the receiver. null when its a contract creation transaction.

value - String: Value transferred in wei.

gasPrice - String: The wei per unit of gas provided by the sender in wei.

gas - Number: Gas provided by the sender.

input - String: The data sent along with the transaction.

Example¶

 web3.eth.getPendingTransactions().then(console.log);
 >  [
     {
         hash: '0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b',
         nonce: 2,
         blockHash: '0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46',
         blockNumber: 3,
         transactionIndex: 0,
         from: '0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b',
         to: '0x6295ee1b4f6dd65047762f924ecd367c17eabf8f',
         value: '123450000000000000',
         gas: 314159,
         gasPrice: '2000000000000',
         input: '0x57cb2fc4'
         v: '0x3d',
         r: '0xaabc9ddafffb2ae0bac4107697547d22d9383667d9e97f5409dd6881ce08f13f',
         s: '0x69e43116be8f842dcd4a0b2f760043737a59534430b762317db21d9ac8c5034'
     },....,{
         hash: '0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b',
         nonce: 3,
         blockHash: '0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46',
         blockNumber: 4,
         transactionIndex: 0,
         from: '0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b',
         to: '0x6295ee1b4f6dd65047762f924ecd367c17eabf8f',
         value: '123450000000000000',
         gas: 314159,
         gasPrice: '2000000000000',
         input: '0x57cb2fc4'
         v: '0x3d',
         r: '0xaabc9ddafffb2ae0bac4107697547d22d9383667d9e97f5409dd6881ce08f13f',
         s: '0x69e43116be8f842dcd4a0b2f760043737a59534430b762317db21d9ac8c5034'
     }
]

getTransactionFromBlock¶

getTransactionFromBlock(hashStringOrNumber, indexNumber [, callback])

Returns a transaction based on a block hash or number and the transactions index position.

Parameters¶

String|Number|BN|BigNumber - A block number or hash. Or the string "genesis", "latest", "earliest", or "pending" as in the default block parameter.
Number - The transactions index position.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns Object - A transaction object, see web3.eth.getTransaction:

Example¶

var transaction = web3.eth.getTransactionFromBlock('0x4534534534', 2)
.then(console.log);
> // see web3.eth.getTransaction

getTransactionReceipt¶

web3.eth.getTransactionReceipt(hash [, callback])

Returns the receipt of a transaction by transaction hash.

주석

The receipt is not available for pending transactions and returns null.

Parameters¶

String - The transaction hash.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns Object - A transaction receipt object, or null when no receipt was found:

status - Boolean: TRUE if the transaction was successful, FALSE, if the EVM reverted the transaction.

blockHash 32 Bytes - String: Hash of the block where this transaction was in.

blockNumber - Number: Block number where this transaction was in.

transactionHash 32 Bytes - String: Hash of the transaction.

transactionIndex- Number: Integer of the transactions index position in the block.

from - String: Address of the sender.

to - String: Address of the receiver. null when its a contract creation transaction.

contractAddress - String: The contract address created, if the transaction was a contract creation, otherwise null.

cumulativeGasUsed - Number: The total amount of gas used when this transaction was executed in the block.

gasUsed- Number: The amount of gas used by this specific transaction alone.

logs - Array: Array of log objects, which this transaction generated.

Example¶

var receipt = web3.eth.getTransactionReceipt('0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b')
.then(console.log);

> {
  "status": true,
  "transactionHash": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b",
  "transactionIndex": 0,
  "blockHash": "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46",
  "blockNumber": 3,
  "contractAddress": "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe",
  "cumulativeGasUsed": 314159,
  "gasUsed": 30234,
  "logs": [{
         // logs as returned by getPastLogs, etc.
     }, ...]
}

getTransactionCount¶

web3.eth.getTransactionCount(address [, defaultBlock] [, callback])

Get the numbers of transactions sent from this address.

Parameters¶

String - The address to get the numbers of transactions from.
Number|String|BN|BigNumber - (optional) If you pass this parameter it will not use the default block set with web3.eth.defaultBlock. Pre-defined block numbers as "latest", "earliest", "pending", and "genesis" can also be used.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns Number - The number of transactions sent from the given address.

Example¶

web3.eth.getTransactionCount("0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe")
.then(console.log);
> 1

sendTransaction¶

web3.eth.sendTransaction(transactionObject [, callback])

Sends a transaction to the network.

Parameters¶

Object - The transaction object to send:
- from - String|Number: The address for the sending account. Uses the web3.eth.defaultAccount property, if not specified. Or an address or index of a local wallet in web3.eth.accounts.wallet.
- to - String: (optional) The destination address of the message, left undefined for a contract-creation transaction.
- value - Number|String|BN|BigNumber: (optional) The value transferred for the transaction in wei, also the endowment if it's a contract-creation transaction.
- gas - Number: (optional, default: To-Be-Determined) The amount of gas to use for the transaction (unused gas is refunded).
- gasPrice - Number|String|BN|BigNumber: (optional) The price of gas for this transaction in wei, defaults to web3.eth.gasPrice.
- data - String: (optional) Either a ABI byte string containing the data of the function call on a contract, or in the case of a contract-creation transaction the initialisation code.
- nonce - Number: (optional) Integer of a nonce. This allows to overwrite your own pending transactions that use the same nonce.
- chain - String: (optional) Defaults to mainnet.
- hardfork - String: (optional) Defaults to petersburg.
- common - Object: (optional) The common object
  
  customChain - Object: The custom chain properties
  
  name - string: (optional) The name of the chain
  
  networkId - number: Network ID of the custom chain
  
  chainId - number: Chain ID of the custom chain
  
  baseChain - string: (optional) mainnet, goerli, kovan, rinkeby, or ropsten
  
  hardfork - string: (optional) chainstart, homestead, dao, tangerineWhistle, spuriousDragon, byzantium, constantinople, petersburg, or istanbul
callback - Function: (optional) Optional callback, returns an error object as first parameter and the result as second.

주석

The from property can also be an address or index from the web3.eth.accounts.wallet. It will then sign locally using the private key of that account, and send the transaction via web3.eth.sendSignedTransaction(). If the properties chain and hardfork or common are not set, Web3 will try to set appropriate values by

querying the network for its chainId and networkId.

Returns¶

The callback will return the 32 bytes transaction hash.

PromiEvent: A promise combined event emitter. Will be resolved when the transaction receipt is available. Additionally the following events are available:

"transactionHash" returns String: Is fired right after the transaction is sent and a transaction hash is available.
"receipt" returns Object: Is fired when the transaction receipt is available.
"confirmation" returns Number, Object: Is fired for every confirmation up to the 12th confirmation. Receives the confirmation number as the first and the receipt as the second argument. Fired from confirmation 0 on, which is the block where its minded.

"error" returns Error and Object|undefined: Is fired if an error occurs during sending. If the transaction was rejected by the network with a receipt, the second parameter will be the receipt.

Example¶

// compiled solidity source code using https://remix.ethereum.org
var code = "603d80600c6000396000f3007c01000000000000000000000000000000000000000000000000000000006000350463c6888fa18114602d57005b6007600435028060005260206000f3";


// using the callback
web3.eth.sendTransaction({
    from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe',
    data: code // deploying a contracrt
}, function(error, hash){
    ...
});

// using the promise
web3.eth.sendTransaction({
    from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe',
    to: '0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe',
    value: '1000000000000000'
})
.then(function(receipt){
    ...
});


// using the event emitter
web3.eth.sendTransaction({
    from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe',
    to: '0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe',
    value: '1000000000000000'
})
.on('transactionHash', function(hash){
    ...
})
.on('receipt', function(receipt){
    ...
})
.on('confirmation', function(confirmationNumber, receipt){ ... })
.on('error', console.error); // If a out of gas error, the second parameter is the receipt.

sendSignedTransaction¶

web3.eth.sendSignedTransaction(signedTransactionData [, callback])

Sends an already signed transaction, generated for example using web3.eth.accounts.signTransaction.

Parameters¶

String - Signed transaction data in HEX format
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

PromiEvent: A promise combined event emitter. Will be resolved when the transaction receipt is available.

Please see the return values for web3.eth.sendTransaction for details.

Example¶

var Tx = require('ethereumjs-tx').Transaction;
var privateKey = Buffer.from('e331b6d69882b4cb4ea581d88e0b604039a3de5967688d3dcffdd2270c0fd109', 'hex');

var rawTx = {
  nonce: '0x00',
  gasPrice: '0x09184e72a000',
  gasLimit: '0x2710',
  to: '0x0000000000000000000000000000000000000000',
  value: '0x00',
  data: '0x7f7465737432000000000000000000000000000000000000000000000000000000600057'
}

var tx = new Tx(rawTx, {'chain':'ropsten'});
tx.sign(privateKey);

var serializedTx = tx.serialize();

// console.log(serializedTx.toString('hex'));
// 0xf889808609184e72a00082271094000000000000000000000000000000000000000080a47f74657374320000000000000000000000000000000000000000000000000000006000571ca08a8bbf888cfa37bbf0bb965423625641fc956967b81d12e23709cead01446075a01ce999b56a8a88504be365442ea61239198e23d1fce7d00fcfc5cd3b44b7215f

web3.eth.sendSignedTransaction('0x' + serializedTx.toString('hex'))
.on('receipt', console.log);

> // see eth.getTransactionReceipt() for details

주석

When use the package ethereumjs-tx at the version of 2.0.0, if we don't specify the parameter chain, it will use mainnet, so if you wan to use at the other network, you should add this parameter chain to specify.

sign¶

web3.eth.sign(dataToSign, address [, callback])

Signs data using a specific account. This account needs to be unlocked.

Parameters¶

String - Data to sign. If String it will be converted using web3.utils.utf8ToHex.
String|Number - Address to sign data with. Or an address or index of a local wallet in web3.eth.accounts.wallet.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

주석

The 2. address parameter can also be an address or index from the web3.eth.accounts.wallet. It will then sign locally using the private key of this account.

Returns¶

Promise returns String - The signature.

Example¶

web3.eth.sign("Hello world", "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe")
.then(console.log);
> "0x30755ed65396facf86c53e6217c52b4daebe72aa4941d89635409de4c9c7f9466d4e9aaec7977f05e923889b33c0d0dd27d7226b6e6f56ce737465c5cfd04be400"

// the below is the same
web3.eth.sign(web3.utils.utf8ToHex("Hello world"), "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe")
.then(console.log);
> "0x30755ed65396facf86c53e6217c52b4daebe72aa4941d89635409de4c9c7f9466d4e9aaec7977f05e923889b33c0d0dd27d7226b6e6f56ce737465c5cfd04be400"

signTransaction¶

web3.eth.signTransaction(transactionObject, address [, callback])

Signs a transaction. This account needs to be unlocked.

Parameters¶

Object - The transaction data to sign web3.eth.sendTransaction() for more.
String - Address to sign transaction with.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns Object - The RLP encoded transaction. The raw property can be used to send the transaction using web3.eth.sendSignedTransaction.

Example¶

web3.eth.signTransaction({
    from: "0xEB014f8c8B418Db6b45774c326A0E64C78914dC0",
    gasPrice: "20000000000",
    gas: "21000",
    to: '0x3535353535353535353535353535353535353535',
    value: "1000000000000000000",
    data: ""
}).then(console.log);
> {
    raw: '0xf86c808504a817c800825208943535353535353535353535353535353535353535880de0b6b3a76400008025a04f4c17305743700648bc4f6cd3038ec6f6af0df73e31757007b7f59df7bee88da07e1941b264348e80c78c4027afc65a87b0a5e43e86742b8ca0823584c6788fd0',
    tx: {
        nonce: '0x0',
        gasPrice: '0x4a817c800',
        gas: '0x5208',
        to: '0x3535353535353535353535353535353535353535',
        value: '0xde0b6b3a7640000',
        input: '0x',
        v: '0x25',
        r: '0x4f4c17305743700648bc4f6cd3038ec6f6af0df73e31757007b7f59df7bee88d',
        s: '0x7e1941b264348e80c78c4027afc65a87b0a5e43e86742b8ca0823584c6788fd0',
        hash: '0xda3be87732110de6c1354c83770aae630ede9ac308d9f7b399ecfba23d923384'
    }
}

call¶

web3.eth.call(callObject [, defaultBlock] [, callback])

Executes a message call transaction, which is directly executed in the VM of the node, but never mined into the blockchain.

Parameters¶

Object - A transaction object, see web3.eth.sendTransaction. For calls the from property is optional however it is highly recommended to explicitly set it or it may default to address(0) depending on your node or provider.
Number|String|BN|BigNumber - (optional) If you pass this parameter it will not use the default block set with web3.eth.defaultBlock. Pre-defined block numbers as "latest", "earliest", "pending", and "genesis" can also be used.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns String: The returned data of the call, e.g. a smart contract functions return value.

Example¶

web3.eth.call({
    to: "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe", // contract address
    data: "0xc6888fa10000000000000000000000000000000000000000000000000000000000000003"
})
.then(console.log);
> "0x000000000000000000000000000000000000000000000000000000000000000a"

estimateGas¶

web3.eth.estimateGas(callObject [, callback])

Executes a message call or transaction and returns the amount of the gas used.

Parameters¶

Object - A transaction object see web3.eth.sendTransaction, with the difference that for calls the from property is optional as well.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns Number - the used gas for the simulated call/transaction.

Example¶

web3.eth.estimateGas({
    to: "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe",
    data: "0xc6888fa10000000000000000000000000000000000000000000000000000000000000003"
})
.then(console.log);
> "0x0000000000000000000000000000000000000000000000000000000000000015"

getPastLogs¶

web3.eth.getPastLogs(options [, callback])

Gets past logs, matching the given options.

Parameters¶

Object - The filter options as follows:

fromBlock - Number|String: The number of the earliest block ("latest" may be given to mean the most recent and "pending" currently mining, block). By default "latest".

toBlock - Number|String: The number of the latest block ("latest" may be given to mean the most recent and "pending" currently mining, block). By default "latest".

address - String|Array: An address or a list of addresses to only get logs from particular account(s).

topics - Array: An array of values which must each appear in the log entries. The order is important, if you want to leave topics out use null, e.g. [null, '0x12...']. You can also pass an array for each topic with options for that topic e.g. [null, ['option1', 'option2']]

Returns¶

Promise returns Array - Array of log objects.

The structure of the returned event Object in the Array looks as follows:

address - String: From which this event originated from.
data - String: The data containing non-indexed log parameter.
topics - Array: An array with max 4 32 Byte topics, topic 1-3 contains indexed parameters of the log.
logIndex - Number: Integer of the event index position in the block.
transactionIndex - Number: Integer of the transaction's index position, the event was created in.
transactionHash 32 Bytes - String: Hash of the transaction this event was created in.
blockHash 32 Bytes - String: Hash of the block where this event was created in. null when its still pending.
blockNumber - Number: The block number where this log was created in. null when still pending.

Example¶

web3.eth.getPastLogs({
    address: "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe",
    topics: ["0x033456732123ffff2342342dd12342434324234234fd234fd23fd4f23d4234"]
})
.then(console.log);

> [{
    data: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
    topics: ['0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7', '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385']
    logIndex: 0,
    transactionIndex: 0,
    transactionHash: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
    blockHash: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
    blockNumber: 1234,
    address: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
},{...}]

getWork¶

web3.eth.getWork([callback])

Gets work for miners to mine on. Returns the hash of the current block, the seedHash, and the boundary condition to be met ("target").

Parameters¶

Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns Array - the mining work with the following structure:

String 32 Bytes - at index 0: current block header pow-hash

String 32 Bytes - at index 1: the seed hash used for the DAG.

String 32 Bytes - at index 2: the boundary condition ("target"), 2^256 / difficulty.

Example¶

web3.eth.getWork()
.then(console.log);
> [
  "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
  "0x5EED00000000000000000000000000005EED0000000000000000000000000000",
  "0xd1ff1c01710000000000000000000000d1ff1c01710000000000000000000000"
]

submitWork¶

web3.eth.submitWork(nonce, powHash, digest, [callback])

Used for submitting a proof-of-work solution.

Parameters¶

String 8 Bytes: The nonce found (64 bits)
String 32 Bytes: The header's pow-hash (256 bits)
String 32 Bytes: The mix digest (256 bits)
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns Boolean - Returns TRUE if the provided solution is valid, otherwise false.

Example¶

web3.eth.submitWork([
    "0x0000000000000001",
    "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
    "0xD1FE5700000000000000000000000000D1FE5700000000000000000000000000"
])
.then(console.log);
> true

requestAccounts¶

web3.eth.requestAccounts([callback])

This method will request/enable the accounts from the current environment it is running (Metamask, Status or Mist). It doesn't work if you're connected to a node with a default Web3.js provider. (WebsocketProvider, HttpProvidder and IpcProvider) This method will only work if you're using the injected provider from a application like Status, Mist or Metamask.

For further information about the behavior of this method please read the EIP of it: EIP-1102

Parameters¶

Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise<Array> - Returns an array of enabled accounts.

Example¶

web3.eth.requestAccounts().then(console.log);
> ['0aae0B295369a9FD31d5F28D9Ec85E40f4cb692BAf', '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe']

getChainId¶

web3.eth.getChainId([callback])

Returns the chain ID of the current connected node as described in the EIP-695.

Returns¶

Promise<Number> - Returns chain ID.

Example¶

web3.eth.getChainId().then(console.log);
> 61

getNodeInfo¶

web3.eth.getNodeInfo([callback])

Returns¶

Promise<String> - The current client version.

Example¶

web3.eth.getNodeInfo().then(console.log);
> "Mist/v0.9.3/darwin/go1.4.1"

getProof¶

web3.eth.getProof(address, storageKey, blockNumber, [callback])

Returns the account and storage-values of the specified account including the Merkle-proof as described in EIP-1186.

Parameters¶

String 20 Bytes: The Address of the account or contract.
Number[] | BigNumber[] | BN[] | String[] 32 Bytes: Array of storage-keys which should be proofed and included. See web3.eth.getStorageAt.
Number | String | BN | BigNumber: Integer block number. Pre-defined block numbers as "latest", "earliest", and "genesis" can also be used.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise<Object> - A account object.

address - String: The address of the account.

balance - String: The balance of the account. See web3.eth.getBalance.

codeHash - String: hash of the code of the account. For a simple Account without code it will return "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"

nonce - String: Nonce of the account.

storageHash - String: SHA3 of the StorageRoot. All storage will deliver a MerkleProof starting with this rootHash.

accountProof - String[]:Array of rlp-serialized MerkleTree-Nodes, starting with the stateRoot-Node, following the path of the SHA3 (address) as key.

storageProof - Object[] Array of storage-entries as requested.

key - String The requested storage key.

value - String The storage value.

Example¶

web3.eth.getProof(
    "0x1234567890123456789012345678901234567890",
    ["0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000001"],
    "latest"
).then(console.log);
> {
    "address": "0x1234567890123456789012345678901234567890",
    "accountProof": [
        "0xf90211a090dcaf88c40c7bbc95a912cbdde67c175767b31173df9ee4b0d733bfdd511c43a0babe369f6b12092f49181ae04ca173fb68d1a5456f18d20fa32cba73954052bda0473ecf8a7e36a829e75039a3b055e51b8332cbf03324ab4af2066bbd6fbf0021a0bbda34753d7aa6c38e603f360244e8f59611921d9e1f128372fec0d586d4f9e0a04e44caecff45c9891f74f6a2156735886eedf6f1a733628ebc802ec79d844648a0a5f3f2f7542148c973977c8a1e154c4300fec92f755f7846f1b734d3ab1d90e7a0e823850f50bf72baae9d1733a36a444ab65d0a6faaba404f0583ce0ca4dad92da0f7a00cbe7d4b30b11faea3ae61b7f1f2b315b61d9f6bd68bfe587ad0eeceb721a07117ef9fc932f1a88e908eaead8565c19b5645dc9e5b1b6e841c5edbdfd71681a069eb2de283f32c11f859d7bcf93da23990d3e662935ed4d6b39ce3673ec84472a0203d26456312bbc4da5cd293b75b840fc5045e493d6f904d180823ec22bfed8ea09287b5c21f2254af4e64fca76acc5cd87399c7f1ede818db4326c98ce2dc2208a06fc2d754e304c48ce6a517753c62b1a9c1d5925b89707486d7fc08919e0a94eca07b1c54f15e299bd58bdfef9741538c7828b5d7d11a489f9c20d052b3471df475a051f9dd3739a927c89e357580a4c97b40234aa01ed3d5e0390dc982a7975880a0a089d613f26159af43616fd9455bb461f4869bfede26f2130835ed067a8b967bfb80",
        "0xf90211a0395d87a95873cd98c21cf1df9421af03f7247880a2554e20738eec2c7507a494a0bcf6546339a1e7e14eb8fb572a968d217d2a0d1f3bc4257b22ef5333e9e4433ca012ae12498af8b2752c99efce07f3feef8ec910493be749acd63822c3558e6671a0dbf51303afdc36fc0c2d68a9bb05dab4f4917e7531e4a37ab0a153472d1b86e2a0ae90b50f067d9a2244e3d975233c0a0558c39ee152969f6678790abf773a9621a01d65cd682cc1be7c5e38d8da5c942e0a73eeaef10f387340a40a106699d494c3a06163b53d956c55544390c13634ea9aa75309f4fd866f312586942daf0f60fb37a058a52c1e858b1382a8893eb9c1f111f266eb9e21e6137aff0dddea243a567000a037b4b100761e02de63ea5f1fcfcf43e81a372dafb4419d126342136d329b7a7ba032472415864b08f808ba4374092003c8d7c40a9f7f9fe9cc8291f62538e1cc14a074e238ff5ec96b810364515551344100138916594d6af966170ff326a092fab0a0d31ac4eef14a79845200a496662e92186ca8b55e29ed0f9f59dbc6b521b116fea090607784fe738458b63c1942bba7c0321ae77e18df4961b2bc66727ea996464ea078f757653c1b63f72aff3dcc3f2a2e4c8cb4a9d36d1117c742833c84e20de994a0f78407de07f4b4cb4f899dfb95eedeb4049aeb5fc1635d65cf2f2f4dfd25d1d7a0862037513ba9d45354dd3e36264aceb2b862ac79d2050f14c95657e43a51b85c80",
        "0xf90171a04ad705ea7bf04339fa36b124fa221379bd5a38ffe9a6112cb2d94be3a437b879a08e45b5f72e8149c01efcb71429841d6a8879d4bbe27335604a5bff8dfdf85dcea00313d9b2f7c03733d6549ea3b810e5262ed844ea12f70993d87d3e0f04e3979ea0b59e3cdd6750fa8b15164612a5cb6567cdfb386d4e0137fccee5f35ab55d0efda0fe6db56e42f2057a071c980a778d9a0b61038f269dd74a0e90155b3f40f14364a08538587f2378a0849f9608942cf481da4120c360f8391bbcc225d811823c6432a026eac94e755534e16f9552e73025d6d9c30d1d7682a4cb5bd7741ddabfd48c50a041557da9a74ca68da793e743e81e2029b2835e1cc16e9e25bd0c1e89d4ccad6980a041dda0a40a21ade3a20fcd1a4abb2a42b74e9a32b02424ff8db4ea708a5e0fb9a09aaf8326a51f613607a8685f57458329b41e938bb761131a5747e066b81a0a16808080a022e6cef138e16d2272ef58434ddf49260dc1de1f8ad6dfca3da5d2a92aaaadc58080",
        "0xf851808080a009833150c367df138f1538689984b8a84fc55692d3d41fe4d1e5720ff5483a6980808080808080808080a0a319c1c415b271afc0adcb664e67738d103ac168e0bc0b7bd2da7966165cb9518080"
        ],
        "balance": 0,
        "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
        "nonce": 0,
        "storageHash": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
        "storageProof": [
        {
            "key": "0x0000000000000000000000000000000000000000000000000000000000000000",
            "value": '0',
            "proof": []
        },
        {
            "key": "0x0000000000000000000000000000000000000000000000000000000000000001",
            "value": '0',
            "proof": []
        }
    ]
}

web3.eth.Contract¶

The web3.eth.Contract object makes it easy to interact with smart contracts on the ethereum blockchain. When you create a new contract object you give it the json interface of the respective smart contract and web3 will auto convert all calls into low level ABI calls over RPC for you.

This allows you to interact with smart contracts as if they were JavaScript objects.

To use it standalone:

new contract¶

new web3.eth.Contract(jsonInterface[, address][, options])

Creates a new contract instance with all its methods and events defined in its json interface object.

Parameters¶

jsonInterface - Object: The json interface for the contract to instantiate
address - String (optional): The address of the smart contract to call.
options - Object (optional): The options of the contract. Some are used as fallbacks for calls and transactions:
- from - String: The address transactions should be made from.
- gasPrice - String: The gas price in wei to use for transactions.
- gas - Number: The maximum gas provided for a transaction (gas limit).
- data - String: The byte code of the contract. Used when the contract gets deployed.

Returns¶

Object: The contract instance with all its methods and events.

Example¶

var myContract = new web3.eth.Contract([...], '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe', {
    from: '0x1234567890123456789012345678901234567891', // default from address
    gasPrice: '20000000000' // default gas price in wei, 20 gwei in this case
});

= Properties =¶

defaultAccount¶

web3.eth.Contract.defaultAccount
contract.defaultAccount // on contract instance

This default address is used as the default "from" property, if no "from" property is specified in for the following methods:

web3.eth.sendTransaction()
web3.eth.call()
new web3.eth.Contract() -> myContract.methods.myMethod().call()
new web3.eth.Contract() -> myContract.methods.myMethod().send()

Property¶

String - 20 Bytes: Any ethereum address. You should have the private key for that address in your node or keystore. (Default is undefined)

Example¶

web3.eth.defaultAccount;
> undefined

// set the default account
web3.eth.defaultAccount = '0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe';

defaultBlock¶

web3.eth.Contract.defaultBlock
contract.defaultBlock // on contract instance

The default block is used for certain methods. You can override it by passing in the defaultBlock as last parameter. The default value of it is "latest".

Property¶

The default block parameters can be one of the following:

Number|BN|BigNumber: A block number
"genesis" - String: The genesis block
"latest" - String: The latest block (current head of the blockchain)
"pending" - String: The currently mined block (including pending transactions)
"earliest" - String: The genesis block

Default is "latest"

Example¶

contract.defaultBlock;
> "latest"

// set the default block
contract.defaultBlock = 231;

defaultHardfork¶

contract.defaultHardfork

The default hardfork property is used for signing transactions locally.

Property¶

The default hardfork property can be one of the following:

"chainstart" - String
"homestead" - String
"dao" - String
"tangerineWhistle" - String
"spuriousDragon" - String
"byzantium" - String
"constantinople" - String
"petersburg" - String
"istanbul" - String

Default is "petersburg"

Example¶

contract.defaultHardfork;
> "petersburg"

// set the default block
contract.defaultHardfork = 'istanbul';

defaultChain¶

contract.defaultChain

The default chain property is used for signing transactions locally.

Property¶

The default chain property can be one of the following:

"mainnet" - String
"goerli" - String
"kovan" - String
"rinkeby" - String
"ropsten" - String

Default is "mainnet"

Example¶

contract.defaultChain;
> "mainnet"

// set the default chain
contract.defaultChain = 'goerli';

defaultCommon¶

contract.defaultCommon

The default common property is used for signing transactions locally.

Property¶

The default common property does contain the following Common object:

customChain - Object: The custom chain properties
- name - string: (optional) The name of the chain
- networkId - number: Network ID of the custom chain
- chainId - number: Chain ID of the custom chain
baseChain - string: (optional) mainnet, goerli, kovan, rinkeby, or ropsten
hardfork - string: (optional) chainstart, homestead, dao, tangerineWhistle, spuriousDragon, byzantium, constantinople, petersburg, or istanbul

Default is undefined.

Example¶

contract.defaultCommon;
> {customChain: {name: 'custom-network', chainId: 1, networkId: 1}, baseChain: 'mainnet', hardfork: 'petersburg'}

// set the default common
contract.defaultCommon = {customChain: {name: 'custom-network', chainId: 1, networkId: 1}, baseChain: 'mainnet', hardfork: 'petersburg'};

transactionBlockTimeout¶

web3.eth.Contract.transcationBlockTimeout
contract.transactionBlockTimeout // on contract instance

The transactionBlockTimeout will be used over a socket based connection. This option does define the amount of new blocks it should wait until the first confirmation happens. This means the PromiEvent rejects with a timeout error when the timeout got exceeded.

Returns¶

number: The current value of transactionBlockTimeout (default: 50)

transactionConfirmationBlocks¶

web3.eth.Contract.transactionConfirmationBlocks
contract.transactionConfirmationBlocks // on contract instance

This defines the number of blocks it requires until a transaction will be handled as confirmed.

Returns¶

number: The current value of transactionConfirmationBlocks (default: 24)

transactionPollingTimeout¶

web3.eth.Contract.transactionPollingTimeout
contract.transactionPollingTimeout // on contract instance

The transactionPollingTimeout will be used over a HTTP connection. This option defines the number of seconds Web3 will wait for a receipt which confirms that a transaction was mined by the network. NB: If this method times out, the transaction may still be pending.

Returns¶

number: The current value of transactionPollingTimeout (default: 750)

handleRevert¶

web3.eth.Contract.handleRevert
contract.handleRevert // on contract instance

The handleRevert options property does default to false and will return the revert reason string if enabled on send or call of a contract method.

주석

The revert reason string and the signature does exist as property on the returned error.

Returns¶

boolean: The current value of handleRevert (default: false)

options¶

myContract.options

The options object for the contract instance. from, gas and gasPrice are used as fallback values when sending transactions.

Properties¶

Object - options:

address - String: The address where the contract is deployed. See options.address.
jsonInterface - Array: The json interface of the contract. See options.jsonInterface.
data - String: The byte code of the contract. Used when the contract gets deployed.
from - String: The address transactions should be made from.
gasPrice - String: The gas price in wei to use for transactions.
gas - Number: The maximum gas provided for a transaction (gas limit).
handleRevert - Boolean: It will otherwise use the default value provided from the Eth module. See handleRevert.
transactionBlockTimeout - Number: It will otherwise use the default value provided from the Eth module. See transactionBlockTimeout.
transactionConfirmationBlocks - Number: It will otherwise use the default value provided from the Eth module. See transactionConfirmationBlocks.
transactionPollingTimeout - Number: It will otherwise use the default value provided from the Eth module. See transactionPollingTimeout.
chain - Number: It will otherwise use the default value provided from the Eth module. See defaultChain.
hardfork - Number: It will otherwise use the default value provided from the Eth module. See defaultHardfork.
common - Number: It will otherwise use the default value provided from the Eth module. See defaultCommon.

Example¶

myContract.options;
> {
    address: '0x1234567890123456789012345678901234567891',
    jsonInterface: [...],
    from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe',
    gasPrice: '10000000000000',
    gas: 1000000
}

myContract.options.from = '0x1234567890123456789012345678901234567891'; // default from address
myContract.options.gasPrice = '20000000000000'; // default gas price in wei
myContract.options.gas = 5000000; // provide as fallback always 5M gas

options.address¶

myContract.options.address

The address used for this contract instance. All transactions generated by web3.js from this contract will contain this address as the "to".

The address will be stored in lowercase.

Property¶

address - String|null: The address for this contract, or null if it's not yet set.

Example¶

myContract.options.address;
> '0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae'

// set a new address
myContract.options.address = '0x1234FFDD...';

options.jsonInterface¶

myContract.options.jsonInterface

The json interface object derived from the ABI of this contract.

Property¶

jsonInterface - Array: The json interface for this contract. Re-setting this will regenerate the methods and events of the contract instance.

Example¶

myContract.options.jsonInterface;
> [{
    "type":"function",
    "name":"foo",
    "inputs": [{"name":"a","type":"uint256"}],
    "outputs": [{"name":"b","type":"address"}]
},{
    "type":"event",
    "name":"Event",
    "inputs": [{"name":"a","type":"uint256","indexed":true},{"name":"b","type":"bytes32","indexed":false}],
}]

// set a new interface
myContract.options.jsonInterface = [...];

= Methods =¶

clone¶

myContract.clone()

Clones the current contract instance.

Parameters¶

none

Returns¶

Object: The new contract instance.

Example¶

var contract1 = new eth.Contract(abi, address, {gasPrice: '12345678', from: fromAddress});

var contract2 = contract1.clone();
contract2.options.address = address2;

(contract1.options.address !== contract2.options.address);
> true

deploy¶

myContract.deploy(options)

Call this function to deploy the contract to the blockchain. After successful deployment the promise will resolve with a new contract instance.

Parameters¶

options - Object: The options used for deployment.
- data - String: The byte code of the contract.
- arguments - Array (optional): The arguments which get passed to the constructor on deployment.

Returns¶

Object: The transaction object:

Array - arguments: The arguments passed to the method before. They can be changed.
Function - send: Will deploy the contract. The promise will resolve with the new contract instance, instead of the receipt!
Function - estimateGas: Will estimate the gas used for deploying.
Function - encodeABI: Encodes the ABI of the deployment, which is contract data + constructor parameters

For details to the methods see the documentation below.

Example¶

myContract.deploy({
    data: '0x12345...',
    arguments: [123, 'My String']
})
.send({
    from: '0x1234567890123456789012345678901234567891',
    gas: 1500000,
    gasPrice: '30000000000000'
}, function(error, transactionHash){ ... })
.on('error', function(error){ ... })
.on('transactionHash', function(transactionHash){ ... })
.on('receipt', function(receipt){
   console.log(receipt.contractAddress) // contains the new contract address
})
.on('confirmation', function(confirmationNumber, receipt){ ... })
.then(function(newContractInstance){
    console.log(newContractInstance.options.address) // instance with the new contract address
});


// When the data is already set as an option to the contract itself
myContract.options.data = '0x12345...';

myContract.deploy({
    arguments: [123, 'My String']
})
.send({
    from: '0x1234567890123456789012345678901234567891',
    gas: 1500000,
    gasPrice: '30000000000000'
})
.then(function(newContractInstance){
    console.log(newContractInstance.options.address) // instance with the new contract address
});


// Simply encoding
myContract.deploy({
    data: '0x12345...',
    arguments: [123, 'My String']
})
.encodeABI();
> '0x12345...0000012345678765432'


// Gas estimation
myContract.deploy({
    data: '0x12345...',
    arguments: [123, 'My String']
})
.estimateGas(function(err, gas){
    console.log(gas);
});

methods¶

myContract.methods.myMethod([param1[, param2[, ...]]])

Creates a transaction object for that method, which then can be called, send, estimated.

The methods of this smart contract are available through:

The name: myContract.methods.myMethod(123)
The name with parameters: myContract.methods['myMethod(uint256)'](123)
The signature: myContract.methods['0x58cf5f10'](123)

This allows calling functions with same name but different parameters from the JavaScript contract object.

Parameters¶

Parameters of any method depend on the smart contracts methods, defined in the JSON interface.

Returns¶

Object: The transaction object:

Array - arguments: The arguments passed to the method before. They can be changed.
Function - call: Will call the "constant" method and execute its smart contract method in the EVM without sending a transaction (Can't alter the smart contract state).
Function - send: Will send a transaction to the smart contract and execute its method (Can alter the smart contract state).
Function - estimateGas: Will estimate the gas used when the method would be executed on chain.
Function - encodeABI: Encodes the ABI for this method. This can be send using a transaction, call the method or passing into another smart contracts method as argument.

For details to the methods see the documentation below.

Example¶

// calling a method

myContract.methods.myMethod(123).call({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'}, function(error, result){
    ...
});

// or sending and using a promise
myContract.methods.myMethod(123).send({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'})
.then(function(receipt){
    // receipt can also be a new contract instance, when coming from a "contract.deploy({...}).send()"
});

// or sending and using the events

myContract.methods.myMethod(123).send({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'})
.on('transactionHash', function(hash){
    ...
})
.on('receipt', function(receipt){
    ...
})
.on('confirmation', function(confirmationNumber, receipt){
    ...
})
.on('error', function(error, receipt) {
    ...
});

methods.myMethod.call¶

myContract.methods.myMethod([param1[, param2[, ...]]]).call(options[, callback])

Will call a "constant" method and execute its smart contract method in the EVM without sending any transaction. Note calling cannot alter the smart contract state.

Parameters¶

options - Object (optional): The options used for calling.
- from - String (optional): The address the call "transaction" should be made from. For calls the from property is optional however it is highly recommended to explicitly set it or it may default to address(0) depending on your node or provider.
- gasPrice - String (optional): The gas price in wei to use for this call "transaction".
- gas - Number (optional): The maximum gas provided for this call "transaction" (gas limit).
callback - Function (optional): This callback will be fired with the result of the smart contract method execution as the second argument, or with an error object as the first argument.

Returns¶

Promise returns Mixed: The return value(s) of the smart contract method. If it returns a single value, it's returned as is. If it has multiple return values they are returned as an object with properties and indices:

Example¶

// using the callback
myContract.methods.myMethod(123).call({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'}, function(error, result){
    ...
});

// using the promise
myContract.methods.myMethod(123).call({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'})
.then(function(result){
    ...
});


// MULTI-ARGUMENT RETURN:

// Solidity
contract MyContract {
    function myFunction() returns(uint256 myNumber, string myString) {
        return (23456, "Hello!%");
    }
}

// web3.js
var MyContract = new web3.eth.Contract(abi, address);
MyContract.methods.myFunction().call()
.then(console.log);
> Result {
    myNumber: '23456',
    myString: 'Hello!%',
    0: '23456', // these are here as fallbacks if the name is not know or given
    1: 'Hello!%'
}


// SINGLE-ARGUMENT RETURN:

// Solidity
contract MyContract {
    function myFunction() returns(string myString) {
        return "Hello!%";
    }
}

// web3.js
var MyContract = new web3.eth.Contract(abi, address);
MyContract.methods.myFunction().call()
.then(console.log);
> "Hello!%"

methods.myMethod.send¶

myContract.methods.myMethod([param1[, param2[, ...]]]).send(options[, callback])

Will send a transaction to the smart contract and execute its method. Note this can alter the smart contract state.

Parameters¶

options - Object: The options used for sending.
- from - String: The address the transaction should be sent from.
- gasPrice - String (optional): The gas price in wei to use for this transaction.
- gas - Number (optional): The maximum gas provided for this transaction (gas limit).
- value - ``Number|String|BN|BigNumber``(optional): The value transferred for the transaction in wei.
callback - Function (optional): This callback will be fired first with the "transactionHash", or with an error object as the first argument.

Returns¶

The callback will return the 32 bytes transaction hash.

PromiEvent: A promise combined event emitter. Will be resolved when the transaction receipt is available, OR if this send() is called from a someContract.deploy(), then the promise will resolve with the new contract instance. Additionally the following events are available:

"transactionHash" returns String: is fired right after the transaction is sent and a transaction hash is available.
"receipt" returns Object: is fired when the transaction receipt is available. Receipts from contracts will have no logs property, but instead an events property with event names as keys and events as properties. See getPastEvents return values for details about the returned event object.
"confirmation" returns Number, Object: is fired for every confirmation up to the 24th confirmation. Receives the confirmation number as the first and the receipt as the second argument. Fired from confirmation 1 on, which is the block where it's minded.
"error" returns Error and Object|undefined: Is fired if an error occurs during sending. If the transaction was rejected by the network with a receipt, the second parameter will be the receipt.

Example¶

// using the callback
myContract.methods.myMethod(123).send({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'}, function(error, transactionHash){
    ...
});

// using the promise
myContract.methods.myMethod(123).send({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'})
.then(function(receipt){
    // receipt can also be a new contract instance, when coming from a "contract.deploy({...}).send()"
});


// using the event emitter
myContract.methods.myMethod(123).send({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'})
.on('transactionHash', function(hash){
    ...
})
.on('confirmation', function(confirmationNumber, receipt){
    ...
})
.on('receipt', function(receipt){
    // receipt example
    console.log(receipt);
    > {
        "transactionHash": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b",
        "transactionIndex": 0,
        "blockHash": "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46",
        "blockNumber": 3,
        "contractAddress": "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe",
        "cumulativeGasUsed": 314159,
        "gasUsed": 30234,
        "events": {
            "MyEvent": {
                returnValues: {
                    myIndexedParam: 20,
                    myOtherIndexedParam: '0x123456789...',
                    myNonIndexParam: 'My String'
                },
                raw: {
                    data: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
                    topics: ['0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7', '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385']
                },
                event: 'MyEvent',
                signature: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
                logIndex: 0,
                transactionIndex: 0,
                transactionHash: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
                blockHash: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
                blockNumber: 1234,
                address: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
            },
            "MyOtherEvent": {
                ...
            },
            "MyMultipleEvent":[{...}, {...}] // If there are multiple of the same event, they will be in an array
        }
    }
})
.on('error', function(error, receipt) { // If the transaction was rejected by the network with a receipt, the second parameter will be the receipt.
    ...
});

methods.myMethod.estimateGas¶

myContract.methods.myMethod([param1[, param2[, ...]]]).estimateGas(options[, callback])

Will call estimate the gas a method execution will take when executed in the EVM without. The estimation can differ from the actual gas used when later sending a transaction, as the state of the smart contract can be different at that time.

Parameters¶

options - Object (optional): The options used for calling.
- from - String (optional): The address the call "transaction" should be made from.
- gas - Number (optional): The maximum gas provided for this call "transaction" (gas limit). Setting a specific value helps to detect out of gas errors. If all gas is used it will return the same number.
- value - ``Number|String|BN|BigNumber``(optional): The value transferred for the call "transaction" in wei.
callback - Function (optional): This callback will be fired with the result of the gas estimation as the second argument, or with an error object as the first argument.

Returns¶

Promise returns Number: The gas amount estimated.

Example¶

// using the callback
myContract.methods.myMethod(123).estimateGas({gas: 5000000}, function(error, gasAmount){
    if(gasAmount == 5000000)
        console.log('Method ran out of gas');
});

// using the promise
myContract.methods.myMethod(123).estimateGas({from: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'})
.then(function(gasAmount){
    ...
})
.catch(function(error){
    ...
});

methods.myMethod.encodeABI¶

myContract.methods.myMethod([param1[, param2[, ...]]]).encodeABI()

Encodes the ABI for this method. This can be used to send a transaction, call a method, or pass it into another smart contracts method as arguments.

Parameters¶

none

Returns¶

String: The encoded ABI byte code to send via a transaction or call.

Example¶

myContract.methods.myMethod(123).encodeABI();
> '0x58cf5f1000000000000000000000000000000000000000000000000000000000000007B'

= Events =¶

once¶

myContract.once(event[, options], callback)

Subscribes to an event and unsubscribes immediately after the first event or error. Will only fire for a single event.

Parameters¶

event - String: The name of the event in the contract, or "allEvents" to get all events.
options - Object (optional): The options used for deployment.
- filter - Object (optional): Lets you filter events by indexed parameters, e.g. {filter: {myNumber: [12,13]}} means all events where "myNumber" is 12 or 13.
- topics - Array (optional): This allows you to manually set the topics for the event filter. If given the filter property and event signature, (topic[0]) will not be set automatically.
callback - Function: This callback will be fired for the first event as the second argument, or an error as the first argument. See getPastEvents return values for details about the event structure.

Returns¶

undefined

Example¶

myContract.once('MyEvent', {
    filter: {myIndexedParam: [20,23], myOtherIndexedParam: '0x123456789...'}, // Using an array means OR: e.g. 20 or 23
    fromBlock: 0
}, function(error, event){ console.log(event); });

// event output example
> {
    returnValues: {
        myIndexedParam: 20,
        myOtherIndexedParam: '0x123456789...',
        myNonIndexParam: 'My String'
    },
    raw: {
        data: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
        topics: ['0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7', '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385']
    },
    event: 'MyEvent',
    signature: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
    logIndex: 0,
    transactionIndex: 0,
    transactionHash: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
    blockHash: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
    blockNumber: 1234,
    address: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
}

events¶

myContract.events.MyEvent([options][, callback])

Subscribe to an event

Parameters¶

options - Object (optional): The options used for deployment.
- filter - Object (optional): Let you filter events by indexed parameters, e.g. {filter: {myNumber: [12,13]}} means all events where "myNumber" is 12 or 13.
- fromBlock - Number|String|BN|BigNumber (optional): The block number (greater than or equal to) from which to get events on. Pre-defined block numbers as "latest", "earlist", "pending", and "genesis" can also be used.
- topics - Array (optional): This allows to manually set the topics for the event filter. If given the filter property and event signature, (topic[0]) will not be set automatically.
callback - Function (optional): This callback will be fired for each event as the second argument, or an error as the first argument.

Returns¶

EventEmitter: The event emitter has the following events:

"data" returns Object: Fires on each incoming event with the event object as argument.
"changed" returns Object: Fires on each event which was removed from the blockchain. The event will have the additional property "removed: true".
"error" returns Object: Fires when an error in the subscription occours.
"connected" returns String: Fires once after the subscription successfully connected. Returns the subscription id.

The structure of the returned event Object looks as follows:

event - String: The event name.
signature - String|Null: The event signature, null if it's an anonymous event.
address - String: Address this event originated from.
returnValues - Object: The return values coming from the event, e.g. {myVar: 1, myVar2: '0x234...'}.
logIndex - Number: Integer of the event index position in the block.
transactionIndex - Number: Integer of the transaction's index position the event was created in.
transactionHash 32 Bytes - String: Hash of the transaction this event was created in.
blockHash 32 Bytes - String: Hash of the block this event was created in. null when it's still pending.
blockNumber - Number: The block number this log was created in. null when still pending.
raw.data - String: The data containing non-indexed log parameter.
raw.topics - Array: An array with max 4 32 Byte topics, topic 1-3 contains indexed parameters of the event.

Example¶

myContract.events.MyEvent({
    filter: {myIndexedParam: [20,23], myOtherIndexedParam: '0x123456789...'}, // Using an array means OR: e.g. 20 or 23
    fromBlock: 0
}, function(error, event){ console.log(event); })
.on("connected", function(subscriptionId){
    console.log(subscriptionId);
})
.on('data', function(event){
    console.log(event); // same results as the optional callback above
})
.on('changed', function(event){
    // remove event from local database
})
.on('error', function(error, receipt) { // If the transaction was rejected by the network with a receipt, the second parameter will be the receipt.
    ...
});

// event output example
> {
    returnValues: {
        myIndexedParam: 20,
        myOtherIndexedParam: '0x123456789...',
        myNonIndexParam: 'My String'
    },
    raw: {
        data: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
        topics: ['0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7', '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385']
    },
    event: 'MyEvent',
    signature: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
    logIndex: 0,
    transactionIndex: 0,
    transactionHash: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
    blockHash: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
    blockNumber: 1234,
    address: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
}

events.allEvents¶

myContract.events.allEvents([options][, callback])

Same as events but receives all events from this smart contract. Optionally the filter property can filter those events.

getPastEvents¶

myContract.getPastEvents(event[, options][, callback])

Gets past events for this contract.

Parameters¶

event - String: The name of the event in the contract, or "allEvents" to get all events.
options - Object (optional): The options used for deployment.
- filter - Object (optional): Lets you filter events by indexed parameters, e.g. {filter: {myNumber: [12,13]}} means all events where "myNumber" is 12 or 13.
- fromBlock - Number|String|BN|BigNumber (optional): The block number (greater than or equal to) from which to get events on. Pre-defined block numbers as "latest", "earlist", "pending", and "genesis" can also be used.
- toBlock - Number|String|BN|BigNumber (optional): The block number (less than or equal to) to get events up to (Defaults to "latest"). Pre-defined block numbers as "latest", "earlist", "pending", and "genesis" can also be used.
- topics - Array (optional): This allows manually setting the topics for the event filter. If given the filter property and event signature, (topic[0]) will not be set automatically.
callback - Function (optional): This callback will be fired with an array of event logs as the second argument, or an error as the first argument.

Returns¶

Promise returns Array: An array with the past event Objects, matching the given event name and filter.

For the structure of a returned event Object see getPastEvents return values.

Example¶

myContract.getPastEvents('MyEvent', {
    filter: {myIndexedParam: [20,23], myOtherIndexedParam: '0x123456789...'}, // Using an array means OR: e.g. 20 or 23
    fromBlock: 0,
    toBlock: 'latest'
}, function(error, events){ console.log(events); })
.then(function(events){
    console.log(events) // same results as the optional callback above
});

> [{
    returnValues: {
        myIndexedParam: 20,
        myOtherIndexedParam: '0x123456789...',
        myNonIndexParam: 'My String'
    },
    raw: {
        data: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
        topics: ['0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7', '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385']
    },
    event: 'MyEvent',
    signature: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
    logIndex: 0,
    transactionIndex: 0,
    transactionHash: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
    blockHash: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
    blockNumber: 1234,
    address: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
},{
    ...
}]

web3.eth.accounts¶

The web3.eth.accounts contains functions to generate Ethereum accounts and sign transactions and data.

주석

This package has NOT been audited and might potentially be unsafe. Take precautions to clear memory properly, store the private keys safely, and test transaction receiving and sending functionality properly before using in production!

To use this package standalone use:

var Accounts = require('web3-eth-accounts');

// Passing in the eth or web3 package is necessary to allow retrieving chainId, gasPrice and nonce automatically
// for accounts.signTransaction().
var accounts = new Accounts('ws://localhost:8546');

create¶

web3.eth.accounts.create([entropy]);

Generates an account object with private key and public key.

Parameters¶

entropy - String (optional): A random string to increase entropy. If given it should be at least 32 characters. If none is given a random string will be generated using randomhex.

Returns¶

Object - The account object with the following structure:

address - string: The account address.

privateKey - string: The accounts private key. This should never be shared or stored unencrypted in localstorage! Also make sure to null the memory after usage.

signTransaction(tx [, callback]) - Function: The function to sign transactions. See web3.eth.accounts.signTransaction() for more.

sign(data) - Function: The function to sign transactions. See web3.eth.accounts.sign() for more.

Example¶

web3.eth.accounts.create();
> {
    address: "0xb8CE9ab6943e0eCED004cDe8e3bBed6568B2Fa01",
    privateKey: "0x348ce564d427a3311b6536bbcff9390d69395b06ed6c486954e971d960fe8709",
    signTransaction: function(tx){...},
    sign: function(data){...},
    encrypt: function(password){...}
}

web3.eth.accounts.create('2435@#@#@±±±±!!!!678543213456764321§34567543213456785432134567');
> {
    address: "0xF2CD2AA0c7926743B1D4310b2BC984a0a453c3d4",
    privateKey: "0xd7325de5c2c1cf0009fac77d3d04a9c004b038883446b065871bc3e831dcd098",
    signTransaction: function(tx){...},
    sign: function(data){...},
    encrypt: function(password){...}
}

web3.eth.accounts.create(web3.utils.randomHex(32));
> {
    address: "0xe78150FaCD36E8EB00291e251424a0515AA1FF05",
    privateKey: "0xcc505ee6067fba3f6fc2050643379e190e087aeffe5d958ab9f2f3ed3800fa4e",
    signTransaction: function(tx){...},
    sign: function(data){...},
    encrypt: function(password){...}
}

privateKeyToAccount¶

web3.eth.accounts.privateKeyToAccount(privateKey [, ignoreLength ]);

Creates an account object from a private key.

For more advanced hierarchial address derivation, see [truffle-hd-awallet-provider](https://github.com/trufflesuite/truffle/tree/develop/packages/hdwallet-provider) package.

Parameters¶

1. privateKey - String: The private key to import. This is 32 bytes of random data. If you are supplying a hexadecimal number, it must have 0x prefix in order to be in line with other Ethereum libraries. 2. ignoreLength - Boolean: If set to true does the privateKey length not get validated.

Returns¶

Object - The account object with the structure seen here.

Example¶

web3.eth.accounts.privateKeyToAccount('0x348ce564d427a3311b6536bbcff9390d69395b06ed6c486954e971d960fe8709');
> {
    address: '0xb8CE9ab6943e0eCED004cDe8e3bBed6568B2Fa01',
    privateKey: '0x348ce564d427a3311b6536bbcff9390d69395b06ed6c486954e971d960fe8709',
    signTransaction: function(tx){...},
    sign: function(data){...},
    encrypt: function(password){...}
}

signTransaction¶

web3.eth.accounts.signTransaction(tx, privateKey [, callback]);

Signs an Ethereum transaction with a given private key.

Parameters¶

tx - Object: The transaction object as follows:
- nonce - String: (optional) The nonce to use when signing this transaction. Default will use web3.eth.getTransactionCount().
- chainId - String: (optional) The chain id to use when signing this transaction. Default will use web3.eth.net.getId().
- to - String: (optional) The recevier of the transaction, can be empty when deploying a contract.
- data - String: (optional) The call data of the transaction, can be empty for simple value transfers.
- value - String: (optional) The value of the transaction in wei.
- gasPrice - String: (optional) The gas price set by this transaction, if empty, it will use web3.eth.getGasPrice()
- gas - String: The gas provided by the transaction.
- chain - String: (optional) Defaults to mainnet.
- hardfork - String: (optional) Defaults to petersburg.
- common - Object: (optional) The common object
  
  customChain - Object: The custom chain properties
  
  name - string: (optional) The name of the chain
  
  networkId - number: Network ID of the custom chain
  
  chainId - number: Chain ID of the custom chain
  
  baseChain - string: (optional) mainnet, goerli, kovan, rinkeby, or ropsten
  
  hardfork - string: (optional) chainstart, homestead, dao, tangerineWhistle, spuriousDragon, byzantium, constantinople, petersburg, or istanbul
privateKey - String: The private key to sign with.
callback - Function: (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returning Object: The signed data RLP encoded transaction, or if returnSignature is true the signature values as follows:

messageHash - String: The hash of the given message.
r - String: First 32 bytes of the signature
s - String: Next 32 bytes of the signature
v - String: Recovery value + 27
rawTransaction - String: The RLP encoded transaction, ready to be send using web3.eth.sendSignedTransaction.
transactionHash - String: The transaction hash for the RLP encoded transaction.

Example¶

web3.eth.accounts.signTransaction({
    to: '0xF0109fC8DF283027b6285cc889F5aA624EaC1F55',
    value: '1000000000',
    gas: 2000000
}, '0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318')
.then(console.log);
> {
    messageHash: '0x31c2f03766b36f0346a850e78d4f7db2d9f4d7d54d5f272a750ba44271e370b1',
    v: '0x25',
    r: '0xc9cf86333bcb065d140032ecaab5d9281bde80f21b9687b3e94161de42d51895',
    s: '0x727a108a0b8d101465414033c3f705a9c7b826e596766046ee1183dbc8aeaa68',
    rawTransaction: '0xf869808504e3b29200831e848094f0109fc8df283027b6285cc889f5aa624eac1f55843b9aca008025a0c9cf86333bcb065d140032ecaab5d9281bde80f21b9687b3e94161de42d51895a0727a108a0b8d101465414033c3f705a9c7b826e596766046ee1183dbc8aeaa68'
    transactionHash: '0xde8db924885b0803d2edc335f745b2b8750c8848744905684c20b987443a9593'
}

web3.eth.accounts.signTransaction({
    to: '0xF0109fC8DF283027b6285cc889F5aA624EaC1F55',
    value: '1000000000',
    gas: 2000000,
    gasPrice: '234567897654321',
    nonce: 0,
    chainId: 1
}, '0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318')
.then(console.log);
> {
    messageHash: '0x6893a6ee8df79b0f5d64a180cd1ef35d030f3e296a5361cf04d02ce720d32ec5',
    r: '0x9ebb6ca057a0535d6186462bc0b465b561c94a295bdb0621fc19208ab149a9c',
    s: '0x440ffd775ce91a833ab410777204d5341a6f9fa91216a6f3ee2c051fea6a0428',
    v: '0x25',
    rawTransaction: '0xf86a8086d55698372431831e848094f0109fc8df283027b6285cc889f5aa624eac1f55843b9aca008025a009ebb6ca057a0535d6186462bc0b465b561c94a295bdb0621fc19208ab149a9ca0440ffd775ce91a833ab410777204d5341a6f9fa91216a6f3ee2c051fea6a0428'
    transactionHash: '0xd8f64a42b57be0d565f385378db2f6bf324ce14a594afc05de90436e9ce01f60'
}

// or with a common
web3.eth.accounts.signTransaction({
    to: '0xF0109fC8DF283027b6285cc889F5aA624EaC1F55',
    value: '1000000000',
    gas: 2000000
    common: {
      baseChain: 'mainnet',
      hardfork: 'petersburg',
      customChain: {
        name: 'custom-chain',
        chainId: 1,
        networkId: 1
      }
    }
}, '0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318')
.then(console.log);

recoverTransaction¶

web3.eth.accounts.recoverTransaction(rawTransaction);

Recovers the Ethereum address which was used to sign the given RLP encoded transaction.

Parameters¶

signature - String: The RLP encoded transaction.

Returns¶

String: The Ethereum address used to sign this transaction.

Example¶

web3.eth.accounts.recoverTransaction('0xf86180808401ef364594f0109fc8df283027b6285cc889f5aa624eac1f5580801ca031573280d608f75137e33fc14655f097867d691d5c4c44ebe5ae186070ac3d5ea0524410802cdc025034daefcdfa08e7d2ee3f0b9d9ae184b2001fe0aff07603d9');
> "0xF0109fC8DF283027b6285cc889F5aA624EaC1F55"

hashMessage¶

web3.eth.accounts.hashMessage(message);

Hashes the given message to be passed web3.eth.accounts.recover() function. The data will be UTF-8 HEX decoded and enveloped as follows: "\x19Ethereum Signed Message:\n" + message.length + message and hashed using keccak256.

Parameters¶

message - String: A message to hash, if its HEX it will be UTF8 decoded before.

Returns¶

String: The hashed message

Example¶

web3.eth.accounts.hashMessage("Hello World")
> "0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2"

// the below results in the same hash
web3.eth.accounts.hashMessage(web3.utils.utf8ToHex("Hello World"))
> "0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2"

sign¶

web3.eth.accounts.sign(data, privateKey);

Signs arbitrary data.

Parameters¶

data - String: The data to sign.
privateKey - String: The private key to sign with.

주석

The value passed as the data parameter will be UTF-8 HEX decoded and wrapped as follows: "\x19Ethereum Signed Message:\n" + message.length + message.

Returns¶

Object: The signature object

message - String: The the given message.
messageHash - String: The hash of the given message.
r - String: First 32 bytes of the signature
s - String: Next 32 bytes of the signature
v - String: Recovery value + 27

Example¶

web3.eth.accounts.sign('Some data', '0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318');
> {
    message: 'Some data',
    messageHash: '0x1da44b586eb0729ff70a73c326926f6ed5a25f5b056e7f47fbc6e58d86871655',
    v: '0x1c',
    r: '0xb91467e570a6466aa9e9876cbcd013baba02900b8979d43fe208a4a4f339f5fd',
    s: '0x6007e74cd82e037b800186422fc2da167c747ef045e5d18a5f5d4300f8e1a029',
    signature: '0xb91467e570a6466aa9e9876cbcd013baba02900b8979d43fe208a4a4f339f5fd6007e74cd82e037b800186422fc2da167c747ef045e5d18a5f5d4300f8e1a0291c'
}

recover¶

web3.eth.accounts.recover(signatureObject);
web3.eth.accounts.recover(message, signature [, preFixed]);
web3.eth.accounts.recover(message, v, r, s [, preFixed]);

Recovers the Ethereum address which was used to sign the given data.

Parameters¶

message|signatureObject - String|Object: Either signed message or hash, or the signature object as following values:
- messageHash - String: The hash of the given message already prefixed with "\x19Ethereum Signed Message:\n" + message.length + message.
- r - String: First 32 bytes of the signature
- s - String: Next 32 bytes of the signature
- v - String: Recovery value + 27
signature - String: The raw RLP encoded signature, OR parameter 2-4 as v, r, s values.
preFixed - Boolean (optional, default: false): If the last parameter is true, the given message will NOT automatically be prefixed with "\x19Ethereum Signed Message:\n" + message.length + message, and assumed to be already prefixed.

Returns¶

String: The Ethereum address used to sign this data.

Example¶

web3.eth.accounts.recover({
    messageHash: '0x1da44b586eb0729ff70a73c326926f6ed5a25f5b056e7f47fbc6e58d86871655',
    v: '0x1c',
    r: '0xb91467e570a6466aa9e9876cbcd013baba02900b8979d43fe208a4a4f339f5fd',
    s: '0x6007e74cd82e037b800186422fc2da167c747ef045e5d18a5f5d4300f8e1a029'
})
> "0x2c7536E3605D9C16a7a3D7b1898e529396a65c23"

// message, signature
web3.eth.accounts.recover('Some data', '0xb91467e570a6466aa9e9876cbcd013baba02900b8979d43fe208a4a4f339f5fd6007e74cd82e037b800186422fc2da167c747ef045e5d18a5f5d4300f8e1a0291c');
> "0x2c7536E3605D9C16a7a3D7b1898e529396a65c23"

// message, v, r, s
web3.eth.accounts.recover('Some data', '0x1c', '0xb91467e570a6466aa9e9876cbcd013baba02900b8979d43fe208a4a4f339f5fd', '0x6007e74cd82e037b800186422fc2da167c747ef045e5d18a5f5d4300f8e1a029');
> "0x2c7536E3605D9C16a7a3D7b1898e529396a65c23"

encrypt¶

web3.eth.accounts.encrypt(privateKey, password);

Encrypts a private key to the web3 keystore v3 standard.

Parameters¶

privateKey - String: The private key to encrypt.
password - String: The password used for encryption.

Returns¶

Object: The encrypted keystore v3 JSON.

Example¶

web3.eth.accounts.encrypt('0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318', 'test!')
> {
    version: 3,
    id: '04e9bcbb-96fa-497b-94d1-14df4cd20af6',
    address: '2c7536e3605d9c16a7a3d7b1898e529396a65c23',
    crypto: {
        ciphertext: 'a1c25da3ecde4e6a24f3697251dd15d6208520efc84ad97397e906e6df24d251',
        cipherparams: { iv: '2885df2b63f7ef247d753c82fa20038a' },
        cipher: 'aes-128-ctr',
        kdf: 'scrypt',
        kdfparams: {
            dklen: 32,
            salt: '4531b3c174cc3ff32a6a7a85d6761b410db674807b2d216d022318ceee50be10',
            n: 262144,
            r: 8,
            p: 1
        },
        mac: 'b8b010fff37f9ae5559a352a185e86f9b9c1d7f7a9f1bd4e82a5dd35468fc7f6'
    }
}

decrypt¶

web3.eth.accounts.decrypt(keystoreJsonV3, password);

Decrypts a keystore v3 JSON, and creates the account.

Parameters¶

encryptedPrivateKey - String: The encrypted private key to decrypt.
password - String: The password used for encryption.

Returns¶

Object: The decrypted account.

Example¶

web3.eth.accounts.decrypt({
    version: 3,
    id: '04e9bcbb-96fa-497b-94d1-14df4cd20af6',
    address: '2c7536e3605d9c16a7a3d7b1898e529396a65c23',
    crypto: {
        ciphertext: 'a1c25da3ecde4e6a24f3697251dd15d6208520efc84ad97397e906e6df24d251',
        cipherparams: { iv: '2885df2b63f7ef247d753c82fa20038a' },
        cipher: 'aes-128-ctr',
        kdf: 'scrypt',
        kdfparams: {
            dklen: 32,
            salt: '4531b3c174cc3ff32a6a7a85d6761b410db674807b2d216d022318ceee50be10',
            n: 262144,
            r: 8,
            p: 1
        },
        mac: 'b8b010fff37f9ae5559a352a185e86f9b9c1d7f7a9f1bd4e82a5dd35468fc7f6'
    }
}, 'test!');
> {
    address: "0x2c7536E3605D9C16a7a3D7b1898e529396a65c23",
    privateKey: "0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318",
    signTransaction: function(tx){...},
    sign: function(data){...},
    encrypt: function(password){...}
}

wallet¶

web3.eth.accounts.wallet;

Contains an in memory wallet with multiple accounts. These accounts can be used when using web3.eth.sendTransaction().

Example¶

web3.eth.accounts.wallet;
> Wallet {
    0: {...}, // account by index
    "0xF0109fC8DF283027b6285cc889F5aA624EaC1F55": {...},  // same account by address
    "0xf0109fc8df283027b6285cc889f5aa624eac1f55": {...},  // same account by address lowercase
    1: {...},
    "0xD0122fC8DF283027b6285cc889F5aA624EaC1d23": {...},
    "0xd0122fc8df283027b6285cc889f5aa624eac1d23": {...},

    add: function(){},
    remove: function(){},
    save: function(){},
    load: function(){},
    clear: function(){},

    length: 2,
}

wallet.create¶

web3.eth.accounts.wallet.create(numberOfAccounts [, entropy]);

Generates one or more accounts in the wallet. If wallets already exist they will not be overridden.

Parameters¶

numberOfAccounts - Number: Number of accounts to create. Leave empty to create an empty wallet.
entropy - String (optional): A string with random characters as additional entropy when generating accounts. If given it should be at least 32 characters.

Returns¶

Object: The wallet object.

Example¶

web3.eth.accounts.wallet.create(2, '54674321§3456764321§345674321§3453647544±±±§±±±!!!43534534534534');
> Wallet {
    0: {...},
    "0xF0109fC8DF283027b6285cc889F5aA624EaC1F55": {...},
    "0xf0109fc8df283027b6285cc889f5aa624eac1f55": {...},
    ...
}

wallet.add¶

web3.eth.accounts.wallet.add(account);

Adds an account using a private key or account object to the wallet.

Parameters¶

account - String|Object: A private key or account object created with web3.eth.accounts.create().

Returns¶

Object: The added account.

Example¶

web3.eth.accounts.wallet.add('0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318');
> {
    index: 0,
    address: '0x2c7536E3605D9C16a7a3D7b1898e529396a65c23',
    privateKey: '0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318',
    signTransaction: function(tx){...},
    sign: function(data){...},
    encrypt: function(password){...}
}

web3.eth.accounts.wallet.add({
    privateKey: '0x348ce564d427a3311b6536bbcff9390d69395b06ed6c486954e971d960fe8709',
    address: '0xb8CE9ab6943e0eCED004cDe8e3bBed6568B2Fa01'
});
> {
    index: 0,
    address: '0xb8CE9ab6943e0eCED004cDe8e3bBed6568B2Fa01',
    privateKey: '0x348ce564d427a3311b6536bbcff9390d69395b06ed6c486954e971d960fe8709',
    signTransaction: function(tx){...},
    sign: function(data){...},
    encrypt: function(password){...}
}

wallet.remove¶

web3.eth.accounts.wallet.remove(account);

Removes an account from the wallet.

Parameters¶

account - String|Number: The account address, or index in the wallet.

Returns¶

Boolean: true if the wallet was removed. false if it couldn't be found.

Example¶

web3.eth.accounts.wallet;
> Wallet {
    0: {...},
    "0xF0109fC8DF283027b6285cc889F5aA624EaC1F55": {...}
    1: {...},
    "0xb8CE9ab6943e0eCED004cDe8e3bBed6568B2Fa01": {...}
    ...
}

web3.eth.accounts.wallet.remove('0xF0109fC8DF283027b6285cc889F5aA624EaC1F55');
> true

web3.eth.accounts.wallet.remove(3);
> false

wallet.clear¶

web3.eth.accounts.wallet.clear();

Securely empties the wallet and removes all its accounts.

Parameters¶

none

Returns¶

Object: The wallet object.

Example¶

web3.eth.accounts.wallet.clear();
> Wallet {
    add: function(){},
    remove: function(){},
    save: function(){},
    load: function(){},
    clear: function(){},

    length: 0
}

wallet.encrypt¶

web3.eth.accounts.wallet.encrypt(password);

Encrypts all wallet accounts to an array of encrypted keystore v3 objects.

Parameters¶

password - String: The password which will be used for encryption.

Returns¶

Array: The encrypted keystore v3.

Example¶

web3.eth.accounts.wallet.encrypt('test');
> [ { version: 3,
    id: 'dcf8ab05-a314-4e37-b972-bf9b86f91372',
    address: '06f702337909c06c82b09b7a22f0a2f0855d1f68',
    crypto:
     { ciphertext: '0de804dc63940820f6b3334e5a4bfc8214e27fb30bb7e9b7b74b25cd7eb5c604',
       cipherparams: [Object],
       cipher: 'aes-128-ctr',
       kdf: 'scrypt',
       kdfparams: [Object],
       mac: 'b2aac1485bd6ee1928665642bf8eae9ddfbc039c3a673658933d320bac6952e3' } },
  { version: 3,
    id: '9e1c7d24-b919-4428-b10e-0f3ef79f7cf0',
    address: 'b5d89661b59a9af0b34f58d19138baa2de48baaf',
    crypto:
     { ciphertext: 'd705ebed2a136d9e4db7e5ae70ed1f69d6a57370d5fbe06281eb07615f404410',
       cipherparams: [Object],
       cipher: 'aes-128-ctr',
       kdf: 'scrypt',
       kdfparams: [Object],
       mac: 'af9eca5eb01b0f70e909f824f0e7cdb90c350a802f04a9f6afe056602b92272b' } }
]

wallet.decrypt¶

web3.eth.accounts.wallet.decrypt(keystoreArray, password);

Decrypts keystore v3 objects.

Parameters¶

keystoreArray - Array: The encrypted keystore v3 objects to decrypt.
password - String: The password which will be used for encryption.

Returns¶

Object: The wallet object.

Example¶

web3.eth.accounts.wallet.decrypt([
  { version: 3,
  id: '83191a81-aaca-451f-b63d-0c5f3b849289',
  address: '06f702337909c06c82b09b7a22f0a2f0855d1f68',
  crypto:
   { ciphertext: '7d34deae112841fba86e3e6cf08f5398dda323a8e4d29332621534e2c4069e8d',
     cipherparams: { iv: '497f4d26997a84d570778eae874b2333' },
     cipher: 'aes-128-ctr',
     kdf: 'scrypt',
     kdfparams:
      { dklen: 32,
        salt: '208dd732a27aa4803bb760228dff18515d5313fd085bbce60594a3919ae2d88d',
        n: 262144,
        r: 8,
        p: 1 },
     mac: '0062a853de302513c57bfe3108ab493733034bf3cb313326f42cf26ea2619cf9' } },
   { version: 3,
  id: '7d6b91fa-3611-407b-b16b-396efb28f97e',
  address: 'b5d89661b59a9af0b34f58d19138baa2de48baaf',
  crypto:
   { ciphertext: 'cb9712d1982ff89f571fa5dbef447f14b7e5f142232bd2a913aac833730eeb43',
     cipherparams: { iv: '8cccb91cb84e435437f7282ec2ffd2db' },
     cipher: 'aes-128-ctr',
     kdf: 'scrypt',
     kdfparams:
      { dklen: 32,
        salt: '08ba6736363c5586434cd5b895e6fe41ea7db4785bd9b901dedce77a1514e8b8',
        n: 262144,
        r: 8,
        p: 1 },
     mac: 'd2eb068b37e2df55f56fa97a2bf4f55e072bef0dd703bfd917717d9dc54510f0' } }
], 'test');
> Wallet {
    0: {...},
    1: {...},
    "0xF0109fC8DF283027b6285cc889F5aA624EaC1F55": {...},
    "0xD0122fC8DF283027b6285cc889F5aA624EaC1d23": {...}
    ...
}

wallet.save¶

web3.eth.accounts.wallet.save(password [, keyName]);

Stores the wallet encrypted and as string in local storage.

주석

Browser only.

Parameters¶

password - String: The password to encrypt the wallet.
keyName - String: (optional) The key used for the local storage position, defaults to "web3js_wallet".

Returns¶

Boolean

Example¶

web3.eth.accounts.wallet.save('test#!$');
> true

wallet.load¶

web3.eth.accounts.wallet.load(password [, keyName]);

Loads a wallet from local storage and decrypts it.

주석

Browser only.

Parameters¶

password - String: The password to decrypt the wallet.
keyName - String: (optional) The key used for the localstorage position, defaults to "web3js_wallet".

Returns¶

Object: The wallet object.

Example¶

web3.eth.accounts.wallet.load('test#!$', 'myWalletKey');
> Wallet {
    0: {...},
    1: {...},
    "0xF0109fC8DF283027b6285cc889F5aA624EaC1F55": {...},
    "0xD0122fC8DF283027b6285cc889F5aA624EaC1d23": {...}
    ...
}

web3.eth.personal¶

The web3-eth-personal package allows you to interact with the Ethereum node's accounts.

주석

Many of these functions send sensitive information, like password. Never call these functions over a unsecured Websocket or HTTP provider, as your password will be sent in plain text!

var Personal = require('web3-eth-personal');

// "Personal.providers.givenProvider" will be set if in an Ethereum supported browser.
var personal = new Personal(Personal.givenProvider || 'ws://some.local-or-remote.node:8546');

// or using the web3 umbrella package

var Web3 = require('web3');
var web3 = new Web3(Web3.givenProvider || 'ws://some.local-or-remote.node:8546');

// -> web3.eth.personal

setProvider¶

web3.setProvider(myProvider)
web3.eth.setProvider(myProvider)
web3.shh.setProvider(myProvider)
web3.bzz.setProvider(myProvider)
...

해당 모듈의 web3 Provider를 변경 또는 설정 합니다. .. note:: web3.eth, web3.shh 등등과 같은 모든 하위 모듈에 대해 동일한 Provider가 설정됩니다. web3.bzz 는 분리된 provider가 예외적으로 적용됩니다.

매개변수(Parameters)¶

Object - myProvider: :ref:Provider를 검증합니다. <web3-providers>.

반환값 (Return)¶

Boolean

예시 (예시 (Example))¶

var Web3 = require('web3');
var web3 = new Web3('http://localhost:8545');
// 또는
var web3 = new Web3(new Web3.providers.HttpProvider('http://localhost:8545'));

// provider를 변경합니다.
web3.setProvider('ws://localhost:8546');

// 또는

web3.setProvider(new Web3.providers.WebsocketProvider('ws://localhost:8546'));

// node.js 에서 IPC Provider를 사용합니다.
var net = require('net');
var web3 = new Web3('/Users/myuser/Library/Ethereum/geth.ipc', net); // mac os 의 경로

// 또는

var web3 = new Web3(new Web3.providers.IpcProvider('/Users/myuser/Library/Ethereum/geth.ipc', net)); // mac os 경로
// 윈도우의 경로 : "\\\\.\\pipe\\geth.ipc"
// 리눅스의 경로: "/users/myuser/.ethereum/geth.ipc"

providers(프로바이더)¶

web3.providers
web3.eth.providers
web3.shh.providers
web3.bzz.providers
...

Object with the following providers:

Object - HttpProvider:http 프로바이더는 더이상 사용되지 않게 되었습니다. 이것은 구독에 사용할 수 없을 것 입니다.

Object - WebsocketProvider: 웹 소켓 프로바이더는 레거시 브라우저에 대한 표준입니다.

Object - IpcProvider: IPC 프로바이더는 로컬노드를 사용하는 nodejs Dapp에 대한 표준입니다. 가장 안전한 연결을 제공합니다.

예시 (예시 (Example))¶

var Web3 = require('web3');
// use the given Provider, e.g in Mist, or instantiate a new websocket provider
//
var web3 = new Web3(Web3.givenProvider || 'ws://remotenode.com:8546');
// or
var web3 = new Web3(Web3.givenProvider || new Web3.providers.WebsocketProvider('ws://remotenode.com:8546'));

// Using the IPC provider in node.js
var net = require('net');

var web3 = new Web3('/Users/myuser/Library/Ethereum/geth.ipc', net); // mac os path
// or
var web3 = new Web3(new Web3.providers.IpcProvider('/Users/myuser/Library/Ethereum/geth.ipc', net)); // mac os path
// on windows the path is: "\\\\.\\pipe\\geth.ipc"
// on linux the path is: "/users/myuser/.ethereum/geth.ipc"

설정하기¶

// ====
// Http
// ====

var Web3HttpProvider = require('web3-providers-http');

var options = {
    keepAlive: true,
    withCredentials: false,
    timeout: 20000, // ms
    headers: [
        {
            name: 'Access-Control-Allow-Origin',
            value: '*'
        },
        {
            ...
        }
    ],
    agent: {
        http: http.Agent(...),
        baseUrl: ''
    }
};

var provider = new Web3HttpProvider('http://localhost:8545', options);

// ==========
// 웹소켓
// ==========

var Web3WsProvider = require('web3-providers-ws');

var options = {
    timeout: 30000, // ms

    // 크레덴셜을 url에 포함해서 사용할 수 있습니다 ex: ws://username:password@localhost:8546
    headers: {
      authorization: 'Basic username:password'
    },

    // 만약 결과값이 크다면 사용할 수 있습니다.
    clientConfig: {
      maxReceivedFrameSize: 100000000,   // bytes - default: 1MiB
      maxReceivedMessageSize: 100000000, // bytes - default: 8MiB
    },

    // 자동 재연결 활성화
    reconnect: {
        auto: true,
        delay: 5000, // ms
        maxAttempts: 5,
        onTimeout: false
    }
};

var ws = new Web3WsProvider('ws://localhost:8546', options);

HTTP 와 Websocket 프로바이더에 대한 정보를 더 얻으려면 밑에 링크를 참고할 수 있습니다.

givenProvider¶

web3.givenProvider
web3.eth.
web3.shh.givenProvider
web3.bzz.givenProvider
...

이더리움 호환 브라우저에서 web3.js 를 사용하면, 이 함수는 해당 브라우저의 네이티브 프로바이더를 반환합니다. 호환 브라우저가 아닐 경우, null 을 반환합니다.

반환값 (Returns)¶

Object: 설정된 givenProvider 또는 null.;

예시 (Example)¶

currentProvider¶

web3.currentProvider
web3.eth.currentProvider
web3.shh.currentProvider
web3.bzz.currentProvider
...

현재 provider 또는 null 을 반환합니다

반환값 (Returns)¶

Object: 현재 설정된 프로바이더 또는 null;

예시 (Example)¶

BatchRequest¶

new web3.BatchRequest()
new web3.eth.BatchRequest()
new web3.shh.BatchRequest()
new web3.bzz.BatchRequest()

없음

반환값 (Returns)¶

Object: 밑에 두 메소드로 이루어져 있습니다:

add(request): batch call에 요청 오브젝트를 추가합니다.

execute(): batch 요청을 실행합니다.

예시 (Example)¶

var contract = new web3.eth.Contract(abi, address);

var batch = new web3.BatchRequest();
batch.add(web3.eth.getBalance.request('0x0000000000000000000000000000000000000000', 'latest', callback));
batch.add(contract.methods.balance(address).call.request({from: '0x0000000000000000000000000000000000000000'}, callback2));
batch.execute();

extend¶

web3.extend(methods)
web3.eth.extend(methods)
web3.shh.extend(methods)
web3.bzz.extend(methods)
...

web3 모듈을 확장할 수 있게 합니다.

인자¶

methods - Object: 메서드 배열이 있는 확장 개체에서는 개체를 아래와 같이 설명한다:
- property - String: (optional) 모듈에 추가할 속성의 이름. 설정된 속성이 없는 경우 모듈에 직접 추가됨.
- methods - Array: 메서드 설명 배열
  
  name - String: 추가할 메서드의 이름.
  
  call - String: RPC 메서드의 이름.
  
  params - Number: (optional) 함수에 대한 파라미터의 갯수, 기본값은 0.
  
  inputFormatter - Array: (optional) 입력 포맷터 함수 배열. 각 어레이 항목은 함수 매개 변수에 응답하므로 일부 매개 변수를 포맷하지 않으려면 대신 null 을 추가하세요.
  
  outputFormatter - ``Function: (optional) 메서드의 출력을 포맷하는 데 사용할 수 있다.

반환값 (Returns)¶

Object: 확장 모듈을 반환합니다.

예시 (Example)¶

web3.extend({
    property: 'myModule',
    methods: [{
        name: 'getBalance',
        call: 'eth_getBalance',
        params: 2,
        inputFormatter: [web3.extend.formatters.inputAddressFormatter, web3.extend.formatters.inputDefaultBlockNumberFormatter],
        outputFormatter: web3.utils.hexToNumberString
    },{
        name: 'getGasPriceSuperFunction',
        call: 'eth_gasPriceSuper',
        params: 2,
        inputFormatter: [null, web3.utils.numberToHex]
    }]
});

web3.extend({
    methods: [{
        name: 'directCall',
        call: 'eth_callForFun',
    }]
});

console.log(web3);
> Web3 {
    myModule: {
        getBalance: function(){},
        getGasPriceSuperFunction: function(){}
    },
    directCall: function(){},
    eth: Eth {...},
    bzz: Bzz {...},
    ...
}

newAccount¶

web3.eth.personal.newAccount(password, [callback])

Creates a new account.

주석

Never call this function over a unsecured Websocket or HTTP provider, as your password will be send in plain text!

Parameters¶

password - String: The password to encrypt this account with.

Returns¶

Promise returns String: The address of the newly created account.

Example¶

web3.eth.personal.newAccount('!@superpassword')
.then(console.log);
> '0x1234567891011121314151617181920212223456'

sign¶

web3.eth.personal.sign(dataToSign, address, password [, callback])

The sign method calculates an Ethereum specific signature with:

sign(keccak256("\x19Ethereum Signed Message:\n" + dataToSign.length + dataToSign)))

Adding a prefix to the message makes the calculated signature recognisable as an Ethereum specific signature.

If you have the original message and the signed message, you can discover the signing account address using web3.eth.personal.ecRecover (See example below)

주석

Sending your account password over an unsecured HTTP RPC connection is highly unsecure.

Parameters¶

String - Data to sign. If String it will be converted using web3.utils.utf8ToHex.
String - Address to sign data with.
String - The password of the account to sign data with.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns String - The signature.

Example¶

web3.eth.personal.sign("Hello world", "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe", "test password!")
.then(console.log);
> "0x30755ed65396facf86c53e6217c52b4daebe72aa4941d89635409de4c9c7f9466d4e9aaec7977f05e923889b33c0d0dd27d7226b6e6f56ce737465c5cfd04be400"

// the below is the same
web3.eth.personal.sign(web3.utils.utf8ToHex("Hello world"), "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe", "test password!")
.then(console.log);
> "0x30755ed65396facf86c53e6217c52b4daebe72aa4941d89635409de4c9c7f9466d4e9aaec7977f05e923889b33c0d0dd27d7226b6e6f56ce737465c5cfd04be400"

// recover the signing account address using original message and signed message
web3.eth.personal.ecRecover("Hello world", "0x30755ed65396...etc...")
.then(console.log);
> "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe"

ecRecover¶

web3.eth.personal.ecRecover(dataThatWasSigned, signature [, callback])

Recovers the account that signed the data.

Parameters¶

String - Data that was signed. If String it will be converted using web3.utils.utf8ToHex.
String - The signature.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns String - The account.

Example¶

web3.eth.personal.ecRecover("Hello world", "0x30755ed65396facf86c53e6217c52b4daebe72aa4941d89635409de4c9c7f9466d4e9aaec7977f05e923889b33c0d0dd27d7226b6e6f56ce737465c5cfd04be400").then(console.log);
> "0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe"

signTransaction¶

web3.eth.personal.signTransaction(transaction, password [, callback])

Signs a transaction. This account needs to be unlocked.

주석

Sending your account password over an unsecured HTTP RPC connection is highly unsecure.

Parameters¶

Object - The transaction data to sign web3.eth.sendTransaction() for more.
String - The password of the from account, to sign the transaction with.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise returns Object - The RLP encoded transaction. The raw property can be used to send the transaction using web3.eth.sendSignedTransaction.

Example¶

web3.eth.signTransaction({
    from: "0xEB014f8c8B418Db6b45774c326A0E64C78914dC0",
    gasPrice: "20000000000",
    gas: "21000",
    to: '0x3535353535353535353535353535353535353535',
    value: "1000000000000000000",
    data: ""
}, 'MyPassword!').then(console.log);
> {
    raw: '0xf86c808504a817c800825208943535353535353535353535353535353535353535880de0b6b3a76400008025a04f4c17305743700648bc4f6cd3038ec6f6af0df73e31757007b7f59df7bee88da07e1941b264348e80c78c4027afc65a87b0a5e43e86742b8ca0823584c6788fd0',
    tx: {
        nonce: '0x0',
        gasPrice: '0x4a817c800',
        gas: '0x5208',
        to: '0x3535353535353535353535353535353535353535',
        value: '0xde0b6b3a7640000',
        input: '0x',
        v: '0x25',
        r: '0x4f4c17305743700648bc4f6cd3038ec6f6af0df73e31757007b7f59df7bee88d',
        s: '0x7e1941b264348e80c78c4027afc65a87b0a5e43e86742b8ca0823584c6788fd0',
        hash: '0xda3be87732110de6c1354c83770aae630ede9ac308d9f7b399ecfba23d923384'
    }
}

sendTransaction¶

web3.eth.personal.sendTransaction(transactionOptions, password [, callback])

This method sends a transaction over the management API.

주석

Sending your account password over an unsecured HTTP RPC connection is highly unsecure.

Parameters¶

Object - The transaction options
String - The passphrase for the current account
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise<string> - The transaction hash.

Example¶

web3.eth.sendTransaction({
    from: "0xEB014f8c8B418Db6b45774c326A0E64C78914dC0",
    gasPrice: "20000000000",
    gas: "21000",
    to: '0x3535353535353535353535353535353535353535',
    value: "1000000000000000000",
    data: ""
}, 'MyPassword!').then(console.log);
> '0xda3be87732110de6c1354c83770aae630ede9ac308d9f7b399ecfba23d923384'

unlockAccount¶

web3.eth.personal.unlockAccount(address, password, unlockDuraction [, callback])

Signs data using a specific account.

주석

Sending your account password over an unsecured HTTP RPC connection is highly unsecure.

Parameters¶

address - String: The account address.
password - String - The password of the account.
unlockDuration - Number - The duration for the account to remain unlocked.

Example¶

web3.eth.personal.unlockAccount("0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe", "test password!", 600)
.then(console.log('Account unlocked!'));
> "Account unlocked!"

lockAccount¶

web3.eth.personal.lockAccount(address [, callback])

Locks the given account.

주석

Sending your account password over an unsecured HTTP RPC connection is highly unsecure.

Parameters¶

1. address - String: The account address. 4. Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise<boolean>

Example¶

web3.eth.personal.lockAccount("0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe")
.then(console.log('Account locked!'));
> "Account locked!"

getAccounts¶

web3.eth.personal.getAccounts([callback])

Returns a list of accounts the node controls by using the provider and calling the RPC method personal_listAccounts. Using web3.eth.accounts.create() will not add accounts into this list. For that use web3.eth.personal.newAccount().

The results are the same as web3.eth.getAccounts() except that calls the RPC method eth_accounts.

Returns¶

Promise<Array> - An array of addresses controlled by node.

Example¶

web3.eth.personal.getAccounts()
.then(console.log);
> ["0x11f4d0A3c12e86B4b5F39B213F7E19D048276DAe", "0xDCc6960376d6C6dEa93647383FfB245CfCed97Cf"]

importRawKey¶

web3.eth.personal.importRawKey(privateKey, password)

Imports the given private key into the key store, encrypting it with the passphrase.

Returns the address of the new account.

주석

Sending your account password over an unsecured HTTP RPC connection is highly unsecure.

Parameters¶

privateKey - String - An unencrypted private key (hex string).
password - String - The password of the account.

Returns¶

Promise<string> - The address of the account.

Example¶

web3.eth.personal.importRawKey("cd3376bb711cb332ee3fb2ca04c6a8b9f70c316fcdf7a1f44ef4c7999483295e", "password1234")
.then(console.log);
> "0x8f337bf484b2fc75e4b0436645dcc226ee2ac531"

web3.eth.ens¶

The web3.eth.ens functions let you interacting with ENS. We recommend reading the documentation ENS is providing to get deeper insights about the internals of the name service.

registryAddress¶

web3.eth.ens.registryAddress;

The registryAddress property can be used to define a custom registry address when you are connected to an unknown chain.

주석

If no address is defined will it try to detect the registry on the chain you are currently connected with and on the call of setProvider in the Eth module will it keep the defined address and use it for the ENS module.

Returns¶

String - The address of the custom registry.

Example¶

web3.eth.ens.registryAddress;
> "0x314159265dD8dbb310642f98f50C066173C1259b"

registry¶

web3.eth.ens.registry;

Returns the network specific ENS registry.

Returns¶

Registry - The current ENS registry.

contract: Contract - The Registry contract with the interface we know from the Contract object.
owner(name, callback): Promise - Deprecated please use getOwner
getOwner(name, callback): Promise
setOwner(name, address, txConfig, callback): PromiEvent
resolver(name, callback): Promise - Deprecated please use getResolver
getResolver(name, callback): Promise
setResolver(name, address, txConfig, callback): PromiEvent
getTTL(name, callback): Promise
setTTL(name, ttl, txConfig, callback): PromiEvent
setSubnodeOwner(name, label, address, txConfig, callback): PromiEvent
setRecord(name, owner, resolver, ttl, txConfig, callback): PromiEvent
setSubnodeRecord(name, label, owner, resolver, ttl, txConfig, callback): PromiEvent
setApprovalForAll(operator, approved, txConfig, callback): PromiEvent
isApprovedForAll(owner, operator, callback): Promise
recordExists(name, callback): Promise

Example¶

web3.eth.ens.registry;
> {
    contract: Contract,
    owner: Function(name, callback), // Deprecated
    getOwner: Function(name, callback),
    setOwner: Function(name, address, txConfig, callback),
    resolver: Function(name, callback), // Deprecated
    getResolver: Function(name, callback),
    setResolver: Function(name, address, txConfig, callback),
    getTTL: Function(name, callback),
    setTTL: Function(name, ttl, txConfig, callback),
    setSubnodeOwner: Function(name, label, address, txConfig, callback),
    setRecord(name, owner, resolver, ttl, txConfig, callback),
    setSubnodeRecord(name, label, owner, resolver, ttl, txConfig, callback),
    setApprovalForAll(operator, approved, txConfig, callback),
    isApprovedForAll(owner, operator, txConfig, callback),
    recordExists(name, callback)
}

resolver¶

web3.eth.ens.resolver(name [, callback]);

Returns the resolver contract to an Ethereum address.

주석

This method is deprecated please use getResolver

Parameters¶

name - String: The ENS name.
callback - Function: (optional) Optional callback

Returns¶

Promise<Resolver> - The ENS resolver for this name.

Example¶

web3.eth.ens.resolver('ethereum.eth').then(function (contract) {
    console.log(contract);
});
> Contract<Resolver>

getResolver¶

web3.eth.ens.getResolver(name [, callback]);

Returns the resolver contract to an Ethereum address.

Parameters¶

name - String: The ENS name.
callback - Function: (optional) Optional callback

Returns¶

Promise<Resolver> - The ENS resolver for this name.

Example¶

web3.eth.ens.getResolver('ethereum.eth').then(function (contract) {
    console.log(contract);
});
> Contract<Resolver>

setResolver¶

web3.eth.ens.setResolver(name, address [, txConfig ] [, callback]);

Does set the resolver contract address of a name.

Parameters¶

name - String: The ENS name.
address - String: The contract address of the deployed Resolver contract.
txConfig - Object: (optional) The transaction options as described ::ref::here <eth-sendtransaction>
callback - Function: (optional) Optional callback

Returns¶

PromiEvent<TransactionReceipt | TransactionRevertInstructionError>

Example¶

web3.eth.ens.setResolver('ethereum.eth', '0x...', {...}).then(function (receipt) {
    console.log(receipt);
});
> {...}

getOwner¶

web3.eth.ens.getOwner(name [, callback]);

Returns the owner of a name.

Parameters¶

name - String: The ENS name.
callback - Function: (optional) Optional callback

Returns¶

Promise<String>` - The address of the registrar (EOA or CA).

Example¶

web3.eth.ens.getOwner('ethereum.eth').then(function (owner) {
    console.log(owner);
});
> '0x...'

setOwner¶

web3.eth.ens.setOwner(name [, txConfig ] [, callback]);

Does set the owner of the given name.

Parameters¶

name - String: The ENS name.
txConfig - Object: (optional) The transaction options as described ::ref::here <eth-sendtransaction>
callback - Function: (optional) Optional callback

Returns¶

PromiEvent<TransactionReceipt | TransactionRevertInstructionError>

Example¶

web3.eth.ens.setOwner('ethereum.eth', {...}).then(function (receipt) {
    console.log(receipt);
});
> {...}

getTTL¶

web3.eth.ens.getTTL(name [, callback]);

Returns the caching TTL (time-to-live) of a name.

Parameters¶

name - String: The ENS name.
callback - Function: (optional) Optional callback

Returns¶

Promise<Number>

Example¶

web3.eth.ens.getTTL('ethereum.eth').then(function (ttl) {
    console.log(ttl);
});
> 100000

setTTL¶

web3.eth.ens.setTTL(name, ttl [, txConfig ] [, callback]);

Does set the caching TTL (time-to-live) of a name.

Parameters¶

name - String: The ENS name.
ttl - Number: The TTL value (uint64)
txConfig - Object: (optional) The transaction options as described ::ref::here <eth-sendtransaction>
callback - Function: (optional) Optional callback

Returns¶

PromiEvent<TransactionReceipt | TransactionRevertInstructionError>

Example¶

web3.eth.ens.setTTL('ethereum.eth', 10000, {...}).then(function (receipt) {
    console.log(receipt);
});
> {...}

setSubnodeOwner¶

web3.eth.ens.setSubnodeOwner(name, label, address [, txConfig ] [, callback]);

Creates a new subdomain of the given node, assigning ownership of it to the specified owner

Parameters¶

name - String: The ENS name.
label - String: The name of the sub-domain or the sha3 hash of it
address - String: The registrar of this sub-domain
txConfig - Object: (optional) The transaction options as described ::ref::here <eth-sendtransaction>
callback - Function: (optional) Optional callback

Returns¶

PromiEvent<TransactionReceipt | TransactionRevertInstructionError>

Example¶

web3.eth.ens.setSubnodeOwner('ethereum.eth', 'web3', '0x...', {...}).then(function (receipt) {
    console.log(receipt); // successfully defined the owner of web3.ethereum.eth
});
> {...}

setRecord¶

web3.eth.ens.setRecord(name, owner, resolver, ttl, [, txConfig ] [, callback]);

Sets the owner, resolver, and TTL for an ENS record in a single operation.

Parameters¶

name - String: The ENS name.
owner - String: The owner of the name record
resolver - String: The resolver address of the name record
ttl - String | Number: Time to live value (uint64)
txConfig - Object: (optional) The transaction options as described ::ref::here <eth-sendtransaction>
callback - Function: (optional) Optional callback

Returns¶

PromiEvent<TransactionReceipt | TransactionRevertInstructionError>

Example¶

web3.eth.ens.setRecord('ethereum.eth', '0x...', '0x...', 1000000, {...}).then(function (receipt) {
    console.log(receipt); // successfully registered ethereum.eth
});
> {...}

setSubnodeRecord¶

web3.eth.ens.setSubnodeRecord(name, label, owner, resolver, ttl, [, txConfig ] [, callback]);

Sets the owner, resolver and TTL for a subdomain, creating it if necessary.

Parameters¶

name - String: The ENS name.
label - String: The name of the sub-domain or the sha3 hash of it
owner - String: The owner of the name record
resolver - String: The resolver address of the name record
ttl - String | Number: Time to live value (uint64)
txConfig - Object: (optional) The transaction options as described ::ref::here <eth-sendtransaction>
callback - Function: (optional) Optional callback

Returns¶

PromiEvent<TransactionReceipt | TransactionRevertInstructionError>

Example¶

web3.eth.ens.setSubnodeRecord('ethereum.eth', 'web3', '0x...', '0x...', 1000000, {...}).then(function (receipt) {
    console.log(receipt); // successfully registered web3.ethereum.eth
});
> {...}

setApprovalForAll¶

web3.eth.ens.setApprovalForAll(operator, approved, [, txConfig ] [, callback]);

Sets or clears an approval. Approved accounts can execute all ENS registry operations on behalf of the caller.

Parameters¶

operator - String: The operator address
approved - Boolean
txConfig - Object: (optional) The transaction options as described ::ref::here <eth-sendtransaction>
callback - Function: (optional) Optional callback

Returns¶

PromiEvent<TransactionReceipt | TransactionRevertInstructionError>

Example¶

web3.eth.ens.setApprovalForAll('0x...', true, {...}).then(function (receipt) {
    console.log(receipt);
});
> {...}

isApprovedForAll¶

web3.eth.ens.isApprovedForAll(owner, operator [, callback]);

Returns true if the operator is approved to make ENS registry operations on behalf of the owner.

Parameters¶

owner - String: The owner address.
operator - String: The operator address.
callback - Function: (optional) Optional callback

Returns¶

Promise<Boolean>

Example¶

web3.eth.ens.isApprovedForAll('0x0...', '0x0...').then(function (isApproved) {
    console.log(isApproved);
})
> true

recordExists¶

web3.eth.ens.recordExists(name [, callback]);

Returns true if node exists in this ENS registry. This will return false for records that are in the legacy ENS registry but have not yet been migrated to the new one.

Parameters¶

name - String: The ENS name.
callback - Function: (optional) Optional callback

Returns¶

Promise<Boolean>

Example¶

web3.eth.ens.recordExists('0x0...', '0x0...').then(function (isExisting) {
    console.log(isExisting);
})
> true

getAddress¶

web3.eth.ens.getAddress(ENSName [, callback]);

Resolves an ENS name to an Ethereum address.

Parameters¶

ENSName - String: The ENS name to resolve.
callback - Function: (optional) Optional callback

Returns¶

String - The Ethereum address of the given name.

Example¶

web3.eth.ens.getAddress('ethereum.eth').then(function (address) {
    console.log(address);
})
> 0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359

setAddress¶

web3.eth.ens.setAddress(ENSName, address [, txConfig ] [, callback]);

Sets the address of an ENS name in his resolver.

Parameters¶

ENSName - String: The ENS name.
address - String: The address to set.
txConfig - Object: (optional) The transaction options as described ::ref::here <eth-sendtransaction>
callback - Function: (optional) Optional callback

Emits an AddrChanged event.

Returns¶

PromiEvent<TransactionReceipt | TransactionRevertInstructionError>

Example¶

web3.eth.ens.setAddress(
    'ethereum.eth',
    '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359',
    {
        from: '0x9CC9a2c777605Af16872E0997b3Aeb91d96D5D8c'
    }
).then(function (result) {
         console.log(result.events);
});
> AddrChanged(...)

// Or using the event emitter

web3.eth.ens.setAddress(
    'ethereum.eth',
    '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359',
    {
        from: '0x9CC9a2c777605Af16872E0997b3Aeb91d96D5D8c'
    }
)
.on('transactionHash', function(hash){
    ...
})
.on('confirmation', function(confirmationNumber, receipt){
    ...
})
.on('receipt', function(receipt){
    ...
})
.on('error', console.error);

// Or listen to the AddrChanged event on the resolver

web3.eth.ens.resolver('ethereum.eth').then(function (resolver) {
    resolver.events.AddrChanged({fromBlock: 0}, function(error, event) {
        console.log(event);
    })
    .on('data', function(event){
        console.log(event);
    })
    .on('changed', function(event){
        // remove event from local database
    })
    .on('error', console.error);
});

For further information on the handling of contract events please see here.

getPubkey¶

web3.eth.ens.getPubkey(ENSName [, callback]);

Returns the X and Y coordinates of the curve point for the public key.

Parameters¶

ENSName - String: The ENS name.
callback - Function: (optional) Optional callback

Returns¶

Promise<Object<String, String>> - The X and Y coordinates.

Example¶

web3.eth.ens.getPubkey('ethereum.eth').then(function (result) {
    console.log(result)
});
> {
    "0": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "1": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "x": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "y": "0x0000000000000000000000000000000000000000000000000000000000000000"
}

setPubkey¶

web3.eth.ens.setPubkey(ENSName, x, y [, txConfig ] [, callback]);

Sets the SECP256k1 public key associated with an ENS node

Parameters¶

ENSName - String: The ENS name.
x - String: The X coordinate of the public key.
y - String: The Y coordinate of the public key.
txConfig - Object: (optional) The transaction options as described ::ref::here <eth-sendtransaction>
callback - Function: (optional) Optional callback

Emits an PubkeyChanged event.

Returns¶

PromiEvent<TransactionReceipt | TransactionRevertInstructionError>

Example¶

web3.eth.ens.setPubkey(
    'ethereum.eth',
    '0x0000000000000000000000000000000000000000000000000000000000000000',
    '0x0000000000000000000000000000000000000000000000000000000000000000',
    {
        from: '0x9CC9a2c777605Af16872E0997b3Aeb91d96D5D8c'
    }
).then(function (result) {
    console.log(result.events);
});
> PubkeyChanged(...)

// Or using the event emitter

web3.eth.ens.setPubkey(
    'ethereum.eth',
    '0x0000000000000000000000000000000000000000000000000000000000000000',
    '0x0000000000000000000000000000000000000000000000000000000000000000',
    {
        from: '0x9CC9a2c777605Af16872E0997b3Aeb91d96D5D8c'
    }
)
.on('transactionHash', function(hash){
    ...
})
.on('confirmation', function(confirmationNumber, receipt){
    ...
})
.on('receipt', function(receipt){
    ...
})
.on('error', console.error);

// Or listen to the PubkeyChanged event on the resolver

web3.eth.ens.resolver('ethereum.eth').then(function (resolver) {
    resolver.events.PubkeyChanged({fromBlock: 0}, function(error, event) {
        console.log(event);
    })
    .on('data', function(event){
        console.log(event);
    })
    .on('changed', function(event){
        // remove event from local database
    })
    .on('error', console.error);
});

For further information on the handling of contract events please see here.

getContent¶

web3.eth.ens.getContent(ENSName [, callback]);

Returns the content hash associated with an ENS node.

Parameters¶

ENSName - String: The ENS name.
callback - Function: (optional) Optional callback

Returns¶

Promise<String> - The content hash associated with an ENS node.

Example¶

web3.eth.ens.getContent('ethereum.eth').then(function (result) {
    console.log(result);
});
> "0x0000000000000000000000000000000000000000000000000000000000000000"

setContent¶

web3.eth.ens.setContent(ENSName, hash [, txConfig ] [, callback]);

Sets the content hash associated with an ENS node.

Parameters¶

ENSName - String: The ENS name.
hash - String: The content hash to set.
txConfig - Object: (optional) The transaction options as described ::ref::here <eth-sendtransaction>
callback - Function: (optional) Optional callback

Emits an ContentChanged event.

Returns¶

PromiEvent<TransactionReceipt | TransactionRevertInstructionError>

Example¶

web3.eth.ens.setContent(
    'ethereum.eth',
    '0x0000000000000000000000000000000000000000000000000000000000000000',
    {
        from: '0x9CC9a2c777605Af16872E0997b3Aeb91d96D5D8c'
    }
).then(function (result) {
         console.log(result.events);
 });
> ContentChanged(...)

// Or using the event emitter

web3.eth.ens.setContent(
    'ethereum.eth',
    '0x0000000000000000000000000000000000000000000000000000000000000000',
    {
        from: '0x9CC9a2c777605Af16872E0997b3Aeb91d96D5D8c'
    }
)
.on('transactionHash', function(hash){
    ...
})
.on('confirmation', function(confirmationNumber, receipt){
    ...
})
.on('receipt', function(receipt){
    ...
})
.on('error', console.error);

// Or listen to the ContentChanged event on the resolver

web3.eth.ens.resolver('ethereum.eth').then(function (resolver) {
    resolver.events.ContentChanged({fromBlock: 0}, function(error, event) {
        console.log(event);
    })
    .on('data', function(event){
        console.log(event);
    })
    .on('changed', function(event){
        // remove event from local database
    })
    .on('error', console.error);
});

For further information on the handling of contract events please see here.

getMultihash¶

web3.eth.ens.getMultihash(ENSName [, callback]);

Returns the multihash associated with an ENS node.

Parameters¶

ENSName - String: The ENS name.
callback - Function: (optional) Optional callback

Returns¶

Promise<String> - The associated multihash.

Example¶

web3.eth.ens.getMultihash('ethereum.eth').then(function (result) {
    console.log(result);
});
> 'QmXpSwxdmgWaYrgMUzuDWCnjsZo5RxphE3oW7VhTMSCoKK'

supportsInterface¶

web3.eth.ens.supportsInterface(name, interfaceId [, callback]);

Returns true if the related Resolver does support the given signature or interfaceId.

Parameters¶

name - String: The ENS name.
interfaceId - String: The signature of the function or the interfaceId as described in the ENS documentation
callback - Function: (optional) Optional callback

Returns¶

Promise<Boolean>

Example¶

web3.eth.ens.supportsInterface('ethereum.eth', 'addr(bytes32').then(function (result) {
    console.log(result);
});
> true

setMultihash¶

web3.eth.ens.setMultihash(ENSName, hash [, txConfig ] [, callback]);

Sets the multihash associated with an ENS node.

Parameters¶

ENSName - String: The ENS name.
hash - String: The multihash to set.
txConfig - Object: (optional) The transaction options as described ::ref::here <eth-sendtransaction>
callback - Function: (optional) Optional callback

Emits an ``MultihashChanged``event.

Returns¶

PromiEvent<TransactionReceipt | TransactionRevertInstructionError>

Example¶

web3.eth.ens.setMultihash(
    'ethereum.eth',
    'QmXpSwxdmgWaYrgMUzuDWCnjsZo5RxphE3oW7VhTMSCoKK',
    {
        from: '0x9CC9a2c777605Af16872E0997b3Aeb91d96D5D8c'
    }
).then(function (result) {
    console.log(result.events);
});
> MultihashChanged(...)

// Or using the event emitter

web3.eth.ens.setMultihash(
    'ethereum.eth',
    'QmXpSwxdmgWaYrgMUzuDWCnjsZo5RxphE3oW7VhTMSCoKK',
    {
        from: '0x9CC9a2c777605Af16872E0997b3Aeb91d96D5D8c'
    }
)
.on('transactionHash', function(hash){
    ...
})
.on('confirmation', function(confirmationNumber, receipt){
    ...
})
.on('receipt', function(receipt){
    ...
})
.on('error', console.error);

For further information on the handling of contract events please see here.

ENS events¶

The ENS API provides the possibility for listening to all ENS related events.

Known resolver events¶

AddrChanged(node bytes32, a address)

2. ContentChanged(node bytes32, hash bytes32) 4. NameChanged(node bytes32, name string) 5. ABIChanged(node bytes32, contentType uint256) 6. PubkeyChanged(node bytes32, x bytes32, y bytes32)

Returns¶

PromiEvent<TransactionReceipt | TransactionRevertInstructionError>

Example¶

web3.eth.ens.resolver('ethereum.eth').then(function (resolver) {
    resolver.events.AddrChanged({fromBlock: 0}, function(error, event) {
        console.log(event);
    })
    .on('data', function(event){
        console.log(event);
    })
    .on('changed', function(event){
        // remove event from local database
    })
    .on('error', console.error);
});
> {
    returnValues: {
        node: '0x123456789...',
        a: '0x123456789...',
    },
    raw: {
        data: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
        topics: [
            '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
            '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385'
        ]
    },
    event: 'AddrChanged',
    signature: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
    logIndex: 0,
    transactionIndex: 0,
    transactionHash: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
    blockHash: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
    blockNumber: 1234,
    address: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
}

Known registry events¶

Transfer(node bytes32, owner address)

2. NewOwner(node bytes32, label bytes32, owner address) 4. NewResolver(node bytes32, resolver address) 5. NewTTL(node bytes32, ttl uint64)

Example¶

web3.eth.ens.resistry.then(function (registry) {
    registry.events.Transfer({fromBlock: 0}, , function(error, event) {
          console.log(event);
      })
      .on('data', function(event){
          console.log(event);
      })
      .on('changed', function(event){
          // remove event from local database
      })
      .on('error', console.error);
});
> {
    returnValues: {
        node: '0x123456789...',
        owner: '0x123456789...',
    },
    raw: {
        data: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
        topics: [
            '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
            '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385'
        ]
    },
    event: 'Transfer',
    signature: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
    logIndex: 0,
    transactionIndex: 0,
    transactionHash: '0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385',
    blockHash: '0xfd43ade1c09fade1c0d57a7af66ab4ead7c2c2eb7b11a91ffdd57a7af66ab4ead7',
    blockNumber: 1234,
    address: '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
}

For further information on the handling of contract events please see here.

web3.eth.Iban¶

The web3.eth.Iban function lets convert Ethereum addresses from and to IBAN and BBAN.

Iban instance¶

This's instance of Iban

> Iban { _iban: 'XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS' }

Iban contructor¶

new web3.eth.Iban(ibanAddress)

Generates a iban object with conversion methods and validity checks. Also has singleton functions for conversion like Iban.toAddress(), Iban.toIban(), Iban.fromAddress(), Iban.fromBban(), Iban.createIndirect(), Iban.isValid().

Parameters¶

String: the IBAN address to instantiate an Iban instance from.

Returns¶

Object - The Iban instance.

Example¶

var iban = new web3.eth.Iban("XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS");
> Iban { _iban: 'XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS' }

toAddress¶

static function

web3.eth.Iban.toAddress(ibanAddress)

Singleton: Converts a direct IBAN address into an Ethereum address.

주석

This method also exists on the IBAN instance.

Parameters¶

String: the IBAN address to convert.

Returns¶

String - The Ethereum address.

Example¶

web3.eth.Iban.toAddress("XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS");
> "0x00c5496aEe77C1bA1f0854206A26DdA82a81D6D8"

toIban¶

static function

web3.eth.Iban.toIban(address)

Singleton: Converts an Ethereum address to a direct IBAN address.

Parameters¶

String: the Ethereum address to convert.

Returns¶

String - The IBAN address.

Example¶

web3.eth.Iban.toIban("0x00c5496aEe77C1bA1f0854206A26DdA82a81D6D8");
> "XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS"

static function, return IBAN instance

fromAddress¶

web3.eth.Iban.fromAddress(address)

Singleton: Converts an Ethereum address to a direct IBAN instance.

Parameters¶

String: the Ethereum address to convert.

Returns¶

Object - The IBAN instance.

Example¶

web3.eth.Iban.fromAddress("0x00c5496aEe77C1bA1f0854206A26DdA82a81D6D8");
> Iban {_iban: "XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS"}

static function, return IBAN instance

fromBban¶

web3.eth.Iban.fromBban(bbanAddress)

Singleton: Converts an BBAN address to a direct IBAN instance.

Parameters¶

String: the BBAN address to convert.

Returns¶

Object - The IBAN instance.

Example¶

web3.eth.Iban.fromBban('ETHXREGGAVOFYORK');
> Iban {_iban: "XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS"}

static function, return IBAN instance

createIndirect¶

web3.eth.Iban.createIndirect(options)

Singleton: Creates an indirect IBAN address from a institution and identifier.

Parameters¶

Object: the options object as follows:
- institution - String: the institution to be assigned
- identifier - String: the identifier to be assigned

Returns¶

Object - The IBAN instance.

Example¶

web3.eth.Iban.createIndirect({
    institution: "XREG",
    identifier: "GAVOFYORK"
});
> Iban {_iban: "XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS"}

static function, return boolean

isValid¶

web3.eth.Iban.isValid(ibanAddress)

Singleton: Checks if an IBAN address is valid.

주석

This method also exists on the IBAN instance.

Parameters¶

String: the IBAN address to check.

Returns¶

Boolean

Example¶

web3.eth.Iban.isValid("XE81ETHXREGGAVOFYORK");
> true

web3.eth.Iban.isValid("XE82ETHXREGGAVOFYORK");
> false // because the checksum is incorrect

prototype.isValid¶

method of Iban instance

web3.eth.Iban.prototype.isValid()

Singleton: Checks if an IBAN address is valid.

주석

This method also exists on the IBAN instance.

Parameters¶

String: the IBAN address to check.

Returns¶

Boolean

Example¶

var iban = new web3.eth.Iban("XE81ETHXREGGAVOFYORK");
iban.isValid();
> true

prototype.isDirect¶

method of Iban instance

web3.eth.Iban.prototype.isDirect()

Checks if the IBAN instance is direct.

Parameters¶

none

Returns¶

Boolean

Example¶

var iban = new web3.eth.Iban("XE81ETHXREGGAVOFYORK");
iban.isDirect();
> false

prototype.isIndirect¶

method of Iban instance

web3.eth.Iban.prototype.isIndirect()

Checks if the IBAN instance is indirect.

Parameters¶

none

Returns¶

Boolean

Example¶

var iban = new web3.eth.Iban("XE81ETHXREGGAVOFYORK");
iban.isIndirect();
> true

prototype.checksum¶

method of Iban instance

web3.eth.Iban.prototype.checksum()

Returns the checksum of the IBAN instance.

Parameters¶

none

Returns¶

String: The checksum of the IBAN

Example¶

var iban = new web3.eth.Iban("XE81ETHXREGGAVOFYORK");
iban.checksum();
> "81"

prototype.institution¶

method of Iban instance

web3.eth.Iban.prototype.institution()

Returns the institution of the IBAN instance.

Parameters¶

none

Returns¶

String: The institution of the IBAN

Example¶

var iban = new web3.eth.Iban("XE81ETHXREGGAVOFYORK");
iban.institution();
> 'XREG'

prototype.client¶

method of Iban instance

web3.eth.Iban.prototype.client()

Returns the client of the IBAN instance.

Parameters¶

none

Returns¶

String: The client of the IBAN

Example¶

var iban = new web3.eth.Iban("XE81ETHXREGGAVOFYORK");
iban.client();
> 'GAVOFYORK'

prototype.toAddress¶

method of Iban instance

web3.eth.Iban.prototype.toString()

Returns the Ethereum address of the IBAN instance.

Parameters¶

none

Returns¶

String: The Ethereum address of the IBAN

Example¶

var iban = new web3.eth.Iban('XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS');
iban.toAddress();
> '0x00c5496aEe77C1bA1f0854206A26DdA82a81D6D8'

prototype.toString¶

method of Iban instance

web3.eth.Iban.prototype.toString()

Returns the IBAN address of the IBAN instance.

Parameters¶

none

Returns¶

String: The IBAN address.

Example¶

var iban = new web3.eth.Iban('XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS');
iban.toString();
> 'XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS'

web3.eth.abi¶

web3.eth.abi 를 사용하면 EVM (Ethereum Virtual Machine)에 대한 함수 호출을 위해 매개 변수를 ABI (Application Binary Interface)로 디코딩 및 인코딩 할 수 있습니다.

encodeFunctionSignature¶

web3.eth.abi.encodeFunctionSignature(functionName);

함수 이름과 함수 타입의 첫 4 바이트를 sha3를 통해 ABI 서명(ABI Signiture)로 인코딩합니다.¶

인자(Parameters)¶

1. functionName - String|Object: 인코딩 할 함수의 이름입니다 or the JSON interface object of the function. If string it has to be in the form function(type,type,...), e.g: myFunction(uint256,uint32[],bytes10,bytes)

반환값(Return)¶

String - 함수의 ABI 서명값

예제(Example)¶

// From a JSON interface object
web3.eth.abi.encodeFunctionSignature({
    name: 'myMethod',
    type: 'function',
    inputs: [{
        type: 'uint256',
        name: 'myNumber'
    },{
        type: 'string',
        name: 'myString'
    }]
})
> 0x24ee0097

// Or string
web3.eth.abi.encodeFunctionSignature('myMethod(uint256,string)')
> '0x24ee0097'

encodeEventSignature¶

web3.eth.abi.encodeEventSignature(eventName);

Encodes the event name to its ABI signature, which are the sha3 hash of the event name including input types.

1. eventName - String|Object: The event name to encode. or the JSON interface object of the event. If string it has to be in the form event(type,type,...), e.g: myEvent(uint256,uint32[],bytes10,bytes)

String - 이벤트의 ABI 서명.

web3.eth.abi.encodeEventSignature('myEvent(uint256,bytes32)')
> 0xf2eeb729e636a8cb783be044acf6b7b1e2c5863735b60d6daae84c366ee87d97

// json 인터페이스 오브젝트에서
web3.eth.abi.encodeEventSignature({
    name: 'myEvent',
    type: 'event',
    inputs: [{
        type: 'uint256',
        name: 'myNumber'
    },{
        type: 'bytes32',
        name: 'myBytes'
    }]
})
> 0xf2eeb729e636a8cb783be044acf6b7b1e2c5863735b60d6daae84c366ee87d97

encodeParameter¶

web3.eth.abi.encodeParameter(type, parameter);

유형에 따라 매개 변수를 ABI 표현으로 인코딩합니다.

type - String|Object: 매개 변수의 유형은 유형 목록은`solidity 문서 <http://solidity.readthedocs.io/en/develop/types.html>`_ 를 참조하십시오.
parameter - Mixed: 인코딩 할 실제 매개 변수입니다.

String - ABI 인코딩된 매개 변수입니다.

web3.eth.abi.encodeParameter('uint256', '2345675643');
> "0x000000000000000000000000000000000000000000000000000000008bd02b7b"

web3.eth.abi.encodeParameter('uint256', '2345675643');
> "0x000000000000000000000000000000000000000000000000000000008bd02b7b"

web3.eth.abi.encodeParameter('bytes32', '0xdf3234');
> "0xdf32340000000000000000000000000000000000000000000000000000000000"

web3.eth.abi.encodeParameter('bytes', '0xdf3234');
> "0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003df32340000000000000000000000000000000000000000000000000000000000"

web3.eth.abi.encodeParameter('bytes32[]', ['0xdf3234', '0xfdfd']);
> "00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002df32340000000000000000000000000000000000000000000000000000000000fdfd000000000000000000000000000000000000000000000000000000000000"

web3.eth.abi.encodeParameter(
    {
        "ParentStruct": {
            "propertyOne": 'uint256',
            "propertyTwo": 'uint256',
            "childStruct": {
                "propertyOne": 'uint256',
                "propertyTwo": 'uint256'
            }
        }
    },
    {
        "propertyOne": 42,
        "propertyTwo": 56,
        "childStruct": {
            "propertyOne": 45,
            "propertyTwo": 78
        }
    }
);
> "0x000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000002d000000000000000000000000000000000000000000000000000000000000004e"

encodeParameters¶

web3.eth.abi.encodeParameters(typesArray, parameters);

JSON interface 오브젝트를 기반으로 함수 매개 변수를 인코딩합니다.¶

인자(Parameters)¶

typesArray - Array<String|Object>|Object: An array with types or a JSON interface of a function. See the solidity documentation for a list of types.
parameters - Array: 인코딩 할 매개 변수입니다.

반환값¶

String - ABI 인코딩 된 매개 변수.

예제¶

web3.eth.abi.encodeParameters(['uint256','string'], ['2345675643', 'Hello!%']);
> "0x000000000000000000000000000000000000000000000000000000008bd02b7b0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000748656c6c6f212500000000000000000000000000000000000000000000000000"

web3.eth.abi.encodeParameters(['uint8[]','bytes32'], [['34','434'], '0x324567fff']);
> "0x0

web3.eth.abi.encodeParameters(
    [
        'uint8[]',
        {
            "ParentStruct": {
                "propertyOne": 'uint256',
                "propertyTwo": 'uint256',
                "ChildStruct": {
                    "propertyOne": 'uint256',
                    "propertyTwo": 'uint256'
                }
            }
        }
    ],
    [
        ['34','434'],
        {
            "propertyOne": '42',
            "propertyTwo": '56',
            "ChildStruct": {
                "propertyOne": '45',
                "propertyTwo": '78'
            }
        }
    ]
);
> "0x00000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000002d000000000000000000000000000000000000000000000000000000000000004e0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000018"

encodeFunctionCall¶

web3.eth.abi.encodeFunctionCall(jsonInterface, parameters);

JSON interface 오브젝트 와 주어진 매개 변수를 사용하여 함수 호출을 인코딩합니다.¶

인자(Parameters)¶

jsonInterface - Object: The JSON interface object of a function.
parameters - Array: 인코딩 할 매개 변수입니다.

반환값¶

String - ABI 인코딩된 함수를 호출합니다. 이는 함수의 서명과 인자를 뜻합니다. [TODO] => The ABI encoded function call. Means function signature + parameters. ------- 예제 -------

web3.eth.abi.encodeFunctionCall({
    name: 'myMethod',
    type: 'function',
    inputs: [{
        type: 'uint256',
        name: 'myNumber'
    },{
        type: 'string',
        name: 'myString'
    }]
}, ['2345675643', 'Hello!%']);
> "0x24ee0097000000000000000000000000000000000000000000000000000000008bd02b7b0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000748656c6c6f212500000000000000000000000000000000000000000000000000"

decodeParameter¶

web3.eth.abi.decodeParameter(type, hexString);

ABI 인코딩 매개 변수를 JavaScript에서 사용 가능한 타입으로 디코딩합니다.

type - String|Object: The type of the parameter, see the solidity documentation for a list of types.
hexString - String: 디코딩 할 ABI 바이트 코드입니다.

Mixed - 디코딩 된 매개 변수.

web3.eth.abi.decodeParameter('uint256', '0x0000000000000000000000000000000000000000000000000000000000000010');
> "16"

web3.eth.abi.decodeParameter('string', '0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000848656c6c6f212521000000000000000000000000000000000000000000000000');
> "Hello!%!"

web3.eth.abi.decodeParameter('string', '0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000848656c6c6f212521000000000000000000000000000000000000000000000000');
> "Hello!%!"

web3.eth.abi.decodeParameter(
    {
        "ParentStruct": {
          "propertyOne": 'uint256',
          "propertyTwo": 'uint256',
          "childStruct": {
            "propertyOne": 'uint256',
            "propertyTwo": 'uint256'
          }
        }
    },

, '0x000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000002d000000000000000000000000000000000000000000000000000000000000004e');
> {
    '0': {
        '0': '42',
        '1': '56',
        '2': {
            '0': '45',
            '1': '78',
            'propertyOne': '45',
            'propertyTwo': '78'
        },
        'childStruct': {
            '0': '45',
            '1': '78',
            'propertyOne': '45',
            'propertyTwo': '78'
        },
        'propertyOne': '42',
        'propertyTwo': '56'
    },
    'ParentStruct': {
        '0': '42',
        '1': '56',
        '2': {
            '0': '45',
            '1': '78',
            'propertyOne': '45',
            'propertyTwo': '78'
        },
        'childStruct': {
            '0': '45',
            '1': '78',
            'propertyOne': '45',
            'propertyTwo': '78'
        },
        'propertyOne': '42',
        'propertyTwo': '56'
    }
}

decodeParameters¶

web3.eth.abi.decodeParameters(typesArray, hexString);

ABI 인코딩 매개 변수를 JavaScript에서 사용 가능한 타입으로 디코딩합니다.¶

인자(Parameters)¶

typesArray - Array<String|Object>|Object: An array with types or a JSON interface outputs array. See the solidity documentation for a list of types.
hexString - String: 디코딩 할 ABI 바이트 코드입니다.

반환값¶

Object - 디코딩 된 매개 변수를 포함하는 결과 오브젝트입니다.

예제¶

web3.eth.abi.decodeParameters(['string', 'uint256'], '0x000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000ea000000000000000000000000000000000000000000000000000000000000000848656c6c6f212521000000000000000000000000000000000000000000000000');
> Result { '0': 'Hello!%!', '1': '234' }

web3.eth.abi.decodeParameters([{
    type: 'string',
    name: 'myString'
},{
    type: 'uint256',
    name: 'myNumber'
}], '0x000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000ea000000000000000000000000000000000000000000000000000000000000000848656c6c6f212521000000000000000000000000000000000000000000000000');
> Result {
    '0': 'Hello!%!',
    '1': '234',
    myString: 'Hello!%!',
    myNumber: '234'
}

web3.eth.abi.decodeParameters([
  'uint8[]',
  {
    "ParentStruct": {
      "propertyOne": 'uint256',
      "propertyTwo": 'uint256',
      "childStruct": {
        "propertyOne": 'uint256',
        "propertyTwo": 'uint256'
      }
    }
  }
], '0x00000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000002d000000000000000000000000000000000000000000000000000000000000004e0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000018');
> Result {
    '0': ['42', '24'],
    '1': {
        '0': '42',
        '1': '56',
        '2':
            {
                '0': '45',
                '1': '78',
                'propertyOne': '45',
                'propertyTwo': '78'
            },
        'childStruct':
            {
                '0': '45',
                '1': '78',
                'propertyOne': '45',
                'propertyTwo': '78'
            },
        'propertyOne': '42',
        'propertyTwo': '56'
    }
}

decodeLog¶

web3.eth.abi.decodeLog(inputs, hexString, topics);

ABI 인코딩 된 로그 데이터 및 인덱싱 된 토픽 데이터를 디코딩합니다.

inputs - Object: A JSON interface inputs array. See the solidity documentation for a list of types.
hexString - String: The ABI byte code in the data field of a log.
topics - Array: An array with the index parameter topics of the log, without the topic[0] if its a non-anonymous event, otherwise with topic[0].

Object - 디코딩 된 매개 변수를 포함하는 결과 오브젝트 입니다.

web3.eth.abi.decodeLog([{
    type: 'string',
    name: 'myString'
},{
    type: 'uint256',
    name: 'myNumber',
    indexed: true
},{
    type: 'uint8',
    name: 'mySmallNumber',
    indexed: true
}],
'0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000748656c6c6f252100000000000000000000000000000000000000000000000000',
['0x000000000000000000000000000000000000000000000000000000000000f310', '0x0000000000000000000000000000000000000000000000000000000000000010']);
> Result {
    '0': 'Hello%!',
    '1': '62224',
    '2': '16',
    myString: 'Hello%!',
    myNumber: '62224',
    mySmallNumber: '16'
}

web3.*.net¶

web3-net 패키지는 이더리움 노드 네트워크 속성과 상호작용을 할 수 있게 합니다.

var Net = require('web3-net');

// "Personal.providers.givenProvider" 는 이더리움 지원 브라우저에 의해 설정됩니다.
var net = new Net(Net.givenProvider || 'ws://some.local-or-remote.node:8546');


// web3 umbrella Package 를 사용하는 방법

var Web3 = require('web3');
var web3 = new Web3(Web3.givenProvider || 'ws://some.local-or-remote.node:8546');

// -> web3.eth.net
// -> web3.bzz.net
// -> web3.shh.net

getId¶

web3.eth.net.getId([callback])
web3.bzz.net.getId([callback])
web3.shh.net.getId([callback])

Gets the current network ID.

Parameters¶

none

Returns¶

Promise returns Number: The network ID.

Example¶

web3.eth.net.getId()
.then(console.log);
> 1

isListening¶

web3.eth.net.isListening([callback])
web3.bzz.net.isListening([callback])
web3.shh.net.isListening([callback])

Checks if the node is listening for peers.

Parameters¶

none

Returns¶

Promise returns Boolean

Example¶

web3.eth.net.isListening()
.then(console.log);
> true

getPeerCount¶

web3.eth.net.getPeerCount([callback])
web3.bzz.net.getPeerCount([callback])
web3.shh.net.getPeerCount([callback])

Get the number of peers connected to.

Parameters¶

none

Returns¶

Promise returns Number

Example¶

web3.eth.net.getPeerCount()
.then(console.log);
> 25

web3.bzz¶

web3-bzz 는 탈중앙화된 파일 저장을 위해 Swarm을 사용할 수 있게 해줍니다. 자세한 정보는 Swarm 문서 를 참고하세요.

var Bzz = require('web3-bzz');

// "ethereum" 객체(Objcet)가 있는지 자동 감지하여 로컬 swarm 노드 또는 swarm-gateways.net에 연결합니다.
// 옵션으로 자신의 프로바이더 URL을 제공 할 수 있습니다. 프로바이더 URL이 제공되지 않으면 기본적으로 "http://swarm-gateways.net"을 사용합니다.
var bzz = new Bzz(Bzz.givenProvider || 'http://swarm-gateways.net');


// or using the web3 umbrella package

var Web3 = require('web3');
var web3 = new Web3(Web3.givenProvider || 'ws://some.local-or-remote.node:8546');

// -> web3.bzz.currentProvider // if Web3.givenProvider was an ethereum provider it will set: "http://localhost:8500" otherwise it will set: "http://swarm-gateways.net"

// 필요한 경우 프로바이더를 수동으로 설정
web3.bzz.setProvider("http://localhost:8500");

setProvider¶

web3.bzz.setProvider(myProvider)

Will change the provider for its module.

주석

umbrella 패키지``web3 ''에서 호출되면 별도로 제공 해야하는``web3.bzz`` 를 제외한 모든 하위 모듈``web3.eth '',``web3.shh ''에 대한 프로바이더를 설정합니다.

인자(Parameters)¶

Object - myProvider: 유효한 프로바이더.

반환값¶

Boolean

예제¶

var Bzz = require('web3-bzz');
var bzz = new Bzz('http://localhost:8500');

// 프로바이더를 변경합니다.
bzz.setProvider('http://swarm-gateways.net');

givenProvider¶

web3.bzz.givenProvider

Ethereum 호환 브라우저에서 web3.js를 사용하면 해당 브라우저에서 현재 기본 프로바이더로 설정됩니다. 브라우저 환경에서 지정된 공급자를 반환하지 않으면 null 을 반환합니다.

반환값¶

Object: 설정된 프로바이더 또는 null;

예제¶

bzz.givenProvider;
> {
    send: function(),
    on: function(),
    bzz: "http://localhost:8500",
    shh: true,
    ...
}

bzz.setProvider(bzz.givenProvider || "http://swarm-gateways.net");

currentProvider¶

bzz.currentProvider

위 함수는 현재의 프로바이더 URL을 제공합니다. 프로바이더가 없을 경우 null 을 반환합니다.

반환값¶

Object: The current provider URL or null;

예제¶

bzz.currentProvider;
> "http://localhost:8500"


if(!bzz.currentProvider) {
    bzz.setProvider("http://swarm-gateways.net");
}

upload¶

web3.bzz.upload(mixed)

파일, 폴더 또는 raw 데이터를 swarm에 업로드합니다.

인자(Parameters)¶

mixed - String|Buffer|Uint8Array|Object: 파일 내용은 Buffer / Uint8Array 로 업로드 가능합니다, 여러 파일 또는 디렉토리 또는 파일에는 다음 유형이 허용됩니다(node.js에서만 가능).
- String|Buffer|Uint8Array: 업로드 할 파일 내용, Uint8Array 또는 Buffer 입니다.
- Object:
  
  파일과 디렉토리에 대한 여러 키 값. 경로는 동일하게 유지됩니다.
  
  -키는 파일 경로 또는 이름이어야합니다 (예 : `` "/foo.txt"``이며 그 값은 다음과 같은 객체입니다.)
  
  -type '': 파일의 MIME 유형 (예 : `` "text / html"). -``data '': 업로드 할 파일 내용, 파일 Uint8Array 또는 Buffer.
  
  Node.js의 디스크에서 파일 또는 디렉토리를 업로드하십시오. 다음 속성이 필요합니다..
  
  -경로 '': 파일 또는 디렉토리의 경로입니다. -``kind '': `` "directory" '', "file" ''또는`` "data"`` 3가지 유형으로 나누어집니다.. -defaultFile ''(선택 사항) : "directory" 일 때 "defaultFile"의 경로 (예 : `` "/index.html".)
  
  브라우저에서 파일 또는 폴더를 업로드하십시오.
  
  -pick '': 시작할 파일 선택기. `` "file",`` "directory" ''또는`` "data"``를 사용할 수 있습니다.

반환값¶

Promise returning String: 매니페스트의 콘텐츠 해시를 반환합니다.

예제¶

var bzz = web3.bzz;

// raw 데이터
bzz.upload("test file").then(function(hash) {
    console.log("Uploaded file. Address:", hash);
})

// raw 폴더
var dir = {
    "/foo.txt": {type: "text/plain", data: "sample file"},
    "/bar.txt": {type: "text/plain", data: "another file"}
};
bzz.upload(dir).then(function(hash) {
    console.log("Uploaded directory. Address:", hash);
});

// 노드에서 디스크 파일 업로드하기
bzz.upload({
    path: "/path/to/thing",      // 업로드할 경로
    kind: "directory",           // 파일인지, 폴더인지 구분 ('file','directory')
    defaultFile: "/index.html"   // 선택적이며 "directory" 에 대해서만 사용 가능한 인자.

})
.then(console.log)
.catch(console.log);

// 브라우저에서 디스크 파일 업로드
bzz.upload({pick: "file"}) // 파일인지, 폴더인지 구분 ('file','directory')
.then(console.log);

download¶

web3.bzz.download(bzzHash [, localpath])

bzzHash - String: 다운로드 할 파일 또는 디렉토리입니다. 해시가 원시 파일 인 경우 버퍼를 반환하고 매니페스트 파일 인 경우 디렉토리 구조를 반환합니다. ``localpath ''가 주어지면 파일을 다운로드 한 경로를 반환합니다.
localpath - String: 컨텐츠를 다운로드 할 로컬 폴더입니다. (node.js 만)

반환값¶

Promise returning Buffer|Object|String: 다운로드 한 파일의 버퍼, 디렉토리 구조의 오브젝트 또는 다운로드 된 경로.

예제¶

var bzz = web3.bzz;

// raw 파일 다운로드

var fileHash = "a5c10851ef054c268a2438f10a21f6efe3dc3dcdcc2ea0e6a1a7a38bf8c91e23"; bzz.download(fileHash).then(function(buffer) {

console.log("Downloaded file:", buffer.toString());

});

// 해시가 매니페스트 파일 인 경우 디렉토리를 다운로드

var dirHash = "7e980476df218c05ecfcb0a2ca73597193a34c5a9d6da84d54e295ecd8e0c641"; bzz.download(dirHash).then(function(dir) {

console.log("Downloaded directory:"); > {

'bar.txt': { type: 'text/plain', data: <Buffer 61 6e 6f 74 68 65 72 20 66 69 6c 65> }, 'foo.txt': { type: 'text/plain', data: <Buffer 73 61 6d 70 6c 65 20 66 69 6c 65> }

}

});

// 파일 / 디렉토리를 디스크로 다운로드 (node.js 에서만 사용가능)

var dirHash = "a5c10851ef054c268a2438f10a21f6efe3dc3dcdcc2ea0e6a1a7a38bf8c91e23"; bzz.download(dirHash, "/target/dir") .then(path => console.log(Downloaded directory to ${path}.)) .catch(console.log);

pick¶

web3.bzz.pick.file()
web3.bzz.pick.directory()
web3.bzz.pick.data()

브라우저에서 파일 선택기를 열어 파일, 디렉토리 또는 데이터를 선택합니다.

인자(Parameters)¶

없음

반환값¶

Promise returning Object: 파일 또는 여러 파일을 반환합니다.

예제¶

web3.bzz.pick.file()
.then(console.log);
> {
    ...
}

web3.shh¶

The web3-shh package allows you to interact with the whisper protocol for broadcasting. For more see Whisper Overview.

var Shh = require('web3-shh');

// "Shh.providers.givenProvider" will be set if in an Ethereum supported browser.
var shh = new Shh(Shh.givenProvider || 'ws://some.local-or-remote.node:8546');

// or using the web3 umbrella package

var Web3 = require('web3');
var web3 = new Web3(Web3.givenProvider || 'ws://some.local-or-remote.node:8546');

// -> web3.shh

setProvider¶

web3.setProvider(myProvider)
web3.eth.setProvider(myProvider)
web3.shh.setProvider(myProvider)
web3.bzz.setProvider(myProvider)
...

해당 모듈의 web3 Provider를 변경 또는 설정 합니다. .. note:: web3.eth, web3.shh 등등과 같은 모든 하위 모듈에 대해 동일한 Provider가 설정됩니다. web3.bzz 는 분리된 provider가 예외적으로 적용됩니다.

매개변수(Parameters)¶

Object - myProvider: :ref:Provider를 검증합니다. <web3-providers>.

반환값 (Return)¶

Boolean

예시 (예시 (Example))¶

var Web3 = require('web3');
var web3 = new Web3('http://localhost:8545');
// 또는
var web3 = new Web3(new Web3.providers.HttpProvider('http://localhost:8545'));

// provider를 변경합니다.
web3.setProvider('ws://localhost:8546');

// 또는

web3.setProvider(new Web3.providers.WebsocketProvider('ws://localhost:8546'));

// node.js 에서 IPC Provider를 사용합니다.
var net = require('net');
var web3 = new Web3('/Users/myuser/Library/Ethereum/geth.ipc', net); // mac os 의 경로

// 또는

var web3 = new Web3(new Web3.providers.IpcProvider('/Users/myuser/Library/Ethereum/geth.ipc', net)); // mac os 경로
// 윈도우의 경로 : "\\\\.\\pipe\\geth.ipc"
// 리눅스의 경로: "/users/myuser/.ethereum/geth.ipc"

providers(프로바이더)¶

web3.providers
web3.eth.providers
web3.shh.providers
web3.bzz.providers
...

Object with the following providers:

Object - HttpProvider:http 프로바이더는 더이상 사용되지 않게 되었습니다. 이것은 구독에 사용할 수 없을 것 입니다.

Object - WebsocketProvider: 웹 소켓 프로바이더는 레거시 브라우저에 대한 표준입니다.

Object - IpcProvider: IPC 프로바이더는 로컬노드를 사용하는 nodejs Dapp에 대한 표준입니다. 가장 안전한 연결을 제공합니다.

예시 (예시 (Example))¶

var Web3 = require('web3');
// use the given Provider, e.g in Mist, or instantiate a new websocket provider
//
var web3 = new Web3(Web3.givenProvider || 'ws://remotenode.com:8546');
// or
var web3 = new Web3(Web3.givenProvider || new Web3.providers.WebsocketProvider('ws://remotenode.com:8546'));

// Using the IPC provider in node.js
var net = require('net');

var web3 = new Web3('/Users/myuser/Library/Ethereum/geth.ipc', net); // mac os path
// or
var web3 = new Web3(new Web3.providers.IpcProvider('/Users/myuser/Library/Ethereum/geth.ipc', net)); // mac os path
// on windows the path is: "\\\\.\\pipe\\geth.ipc"
// on linux the path is: "/users/myuser/.ethereum/geth.ipc"

설정하기¶

// ====
// Http
// ====

var Web3HttpProvider = require('web3-providers-http');

var options = {
    keepAlive: true,
    withCredentials: false,
    timeout: 20000, // ms
    headers: [
        {
            name: 'Access-Control-Allow-Origin',
            value: '*'
        },
        {
            ...
        }
    ],
    agent: {
        http: http.Agent(...),
        baseUrl: ''
    }
};

var provider = new Web3HttpProvider('http://localhost:8545', options);

// ==========
// 웹소켓
// ==========

var Web3WsProvider = require('web3-providers-ws');

var options = {
    timeout: 30000, // ms

    // 크레덴셜을 url에 포함해서 사용할 수 있습니다 ex: ws://username:password@localhost:8546
    headers: {
      authorization: 'Basic username:password'
    },

    // 만약 결과값이 크다면 사용할 수 있습니다.
    clientConfig: {
      maxReceivedFrameSize: 100000000,   // bytes - default: 1MiB
      maxReceivedMessageSize: 100000000, // bytes - default: 8MiB
    },

    // 자동 재연결 활성화
    reconnect: {
        auto: true,
        delay: 5000, // ms
        maxAttempts: 5,
        onTimeout: false
    }
};

var ws = new Web3WsProvider('ws://localhost:8546', options);

HTTP 와 Websocket 프로바이더에 대한 정보를 더 얻으려면 밑에 링크를 참고할 수 있습니다.

givenProvider¶

web3.givenProvider
web3.eth.
web3.shh.givenProvider
web3.bzz.givenProvider
...

이더리움 호환 브라우저에서 web3.js 를 사용하면, 이 함수는 해당 브라우저의 네이티브 프로바이더를 반환합니다. 호환 브라우저가 아닐 경우, null 을 반환합니다.

반환값 (Returns)¶

Object: 설정된 givenProvider 또는 null.;

예시 (Example)¶

currentProvider¶

web3.currentProvider
web3.eth.currentProvider
web3.shh.currentProvider
web3.bzz.currentProvider
...

현재 provider 또는 null 을 반환합니다

반환값 (Returns)¶

Object: 현재 설정된 프로바이더 또는 null;

예시 (Example)¶

BatchRequest¶

new web3.BatchRequest()
new web3.eth.BatchRequest()
new web3.shh.BatchRequest()
new web3.bzz.BatchRequest()

없음

반환값 (Returns)¶

Object: 밑에 두 메소드로 이루어져 있습니다:

add(request): batch call에 요청 오브젝트를 추가합니다.

execute(): batch 요청을 실행합니다.

예시 (Example)¶

var contract = new web3.eth.Contract(abi, address);

var batch = new web3.BatchRequest();
batch.add(web3.eth.getBalance.request('0x0000000000000000000000000000000000000000', 'latest', callback));
batch.add(contract.methods.balance(address).call.request({from: '0x0000000000000000000000000000000000000000'}, callback2));
batch.execute();

extend¶

web3.extend(methods)
web3.eth.extend(methods)
web3.shh.extend(methods)
web3.bzz.extend(methods)
...

web3 모듈을 확장할 수 있게 합니다.

인자¶

methods - Object: 메서드 배열이 있는 확장 개체에서는 개체를 아래와 같이 설명한다:
- property - String: (optional) 모듈에 추가할 속성의 이름. 설정된 속성이 없는 경우 모듈에 직접 추가됨.
- methods - Array: 메서드 설명 배열
  
  name - String: 추가할 메서드의 이름.
  
  call - String: RPC 메서드의 이름.
  
  params - Number: (optional) 함수에 대한 파라미터의 갯수, 기본값은 0.
  
  inputFormatter - Array: (optional) 입력 포맷터 함수 배열. 각 어레이 항목은 함수 매개 변수에 응답하므로 일부 매개 변수를 포맷하지 않으려면 대신 null 을 추가하세요.
  
  outputFormatter - ``Function: (optional) 메서드의 출력을 포맷하는 데 사용할 수 있다.

반환값 (Returns)¶

Object: 확장 모듈을 반환합니다.

예시 (Example)¶

web3.extend({
    property: 'myModule',
    methods: [{
        name: 'getBalance',
        call: 'eth_getBalance',
        params: 2,
        inputFormatter: [web3.extend.formatters.inputAddressFormatter, web3.extend.formatters.inputDefaultBlockNumberFormatter],
        outputFormatter: web3.utils.hexToNumberString
    },{
        name: 'getGasPriceSuperFunction',
        call: 'eth_gasPriceSuper',
        params: 2,
        inputFormatter: [null, web3.utils.numberToHex]
    }]
});

web3.extend({
    methods: [{
        name: 'directCall',
        call: 'eth_callForFun',
    }]
});

console.log(web3);
> Web3 {
    myModule: {
        getBalance: function(){},
        getGasPriceSuperFunction: function(){}
    },
    directCall: function(){},
    eth: Eth {...},
    bzz: Bzz {...},
    ...
}

getId¶

web3.eth.net.getId([callback])
web3.bzz.net.getId([callback])
web3.shh.net.getId([callback])

Gets the current network ID.

Parameters¶

none

Returns¶

Promise returns Number: The network ID.

Example¶

web3.eth.net.getId()
.then(console.log);
> 1

isListening¶

web3.eth.net.isListening([callback])
web3.bzz.net.isListening([callback])
web3.shh.net.isListening([callback])

Checks if the node is listening for peers.

Parameters¶

none

Returns¶

Promise returns Boolean

Example¶

web3.eth.net.isListening()
.then(console.log);
> true

getPeerCount¶

web3.eth.net.getPeerCount([callback])
web3.bzz.net.getPeerCount([callback])
web3.shh.net.getPeerCount([callback])

Get the number of peers connected to.

Parameters¶

none

Returns¶

Promise returns Number

Example¶

web3.eth.net.getPeerCount()
.then(console.log);
> 25

getVersion¶

web3.shh.getVersion([callback])

Returns the version of the running whisper.

Parameters¶

Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

String - The version of the current whisper running.

Example¶

web3.shh.getVersion()
.then(console.log);
> "5.0"

getInfo¶

web3.shh.getInfo([callback])

Gets information about the current whisper node.

Parameters¶

Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Object - The information of the node with the following properties:

messages - Number: Number of currently floating messages.

maxMessageSize - Number: The current message size limit in bytes.

memory - Number: The memory size of the floating messages in bytes.

minPow - Number: The current minimum PoW requirement.

Example¶

web3.shh.getInfo()
.then(console.log);
> {
    "minPow": 0.8,
    "maxMessageSize": 12345,
    "memory": 1234335,
    "messages": 20
}

setMaxMessageSize¶

web3.shh.setMaxMessageSize(size, [callback])

Sets the maximal message size allowed by this node. Incoming and outgoing messages with a larger size will be rejected. Whisper message size can never exceed the limit imposed by the underlying P2P protocol (10 Mb).

Parameters¶

Number - Message size in bytes.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Boolean - true on success, error on failure.

Example¶

web3.shh.setMaxMessageSize(1234565)
.then(console.log);
> true

setMinPoW¶

web3.shh.setMinPoW(pow, [callback])

Sets the minimal PoW required by this node.

This experimental function was introduced for the future dynamic adjustment of PoW requirement. If the node is overwhelmed with messages, it should raise the PoW requirement and notify the peers. The new value should be set relative to the old value (e.g. double). The old value can be obtained via web3.shh.getInfo().

Parameters¶

Number - The new PoW requirement.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Boolean - true on success, error on failure.

Example¶

web3.shh.setMinPoW(0.9)
.then(console.log);
> true

markTrustedPeer¶

web3.shh.markTrustedPeer(enode, [callback])

Marks specific peer trusted, which will allow it to send historic (expired) messages.

주석

This function is not adding new nodes, the node needs to be an existing peer.

Parameters¶

String - Enode of the trusted peer.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Boolean - true on success, error on failure.

Example¶

web3.shh.markTrustedPeer()
.then(console.log);
> true

newKeyPair¶

web3.shh.newKeyPair([callback])

Generates a new public and private key pair for message decryption and encryption.

Parameters¶

Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

String - Key ID on success and an error on failure.

Example¶

web3.shh.newKeyPair()
.then(console.log);
> "5e57b9ffc2387e18636e0a3d0c56b023264c16e78a2adcba1303cefc685e610f"

addPrivateKey¶

web3.shh.addPrivateKey(privateKey, [callback])

Stores a key pair derived from a private key, and returns its ID.

Parameters¶

String - The private key as HEX bytes to import.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

String - Key ID on success and an error on failure.

Example¶

web3.shh.addPrivateKey('0x8bda3abeb454847b515fa9b404cede50b1cc63cfdeddd4999d074284b4c21e15')
.then(console.log);
> "3e22b9ffc2387e18636e0a3d0c56b023264c16e78a2adcba1303cefc685e610f"

deleteKeyPair¶

web3.shh.deleteKeyPair(id, [callback])

Deletes the specifies key if it exists.

Parameters¶

String - The key pair ID, returned by the creation functions (shh.newKeyPair and shh.addPrivateKey).
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Boolean - true on success, error on failure.

Example¶

web3.shh.deleteKeyPair('3e22b9ffc2387e18636e0a3d0c56b023264c16e78a2adcba1303cefc685e610f')
.then(console.log);
> true

hasKeyPair¶

web3.shh.hasKeyPair(id, [callback])

Checks if the whisper node has a private key of a key pair matching the given ID.

Parameters¶

String - The key pair ID, returned by the creation functions (shh.newKeyPair and shh.addPrivateKey).
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Boolean - true on if the key pair exist in the node, false if not. Error on failure.

Example¶

web3.shh.hasKeyPair('fe22b9ffc2387e18636e0a3d0c56b023264c16e78a2adcba1303cefc685e610f')
.then(console.log);
> true

getPublicKey¶

web3.shh.getPublicKey(id, [callback])

Returns the public key for a key pair ID.

Parameters¶

String - The key pair ID, returned by the creation functions (shh.newKeyPair and shh.addPrivateKey).
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

String - Public key on success and an error on failure.

Example¶

web3.shh.getPublicKey('3e22b9ffc2387e18636e0a3d0c56b023264c16e78a2adcba1303cefc685e610f')
.then(console.log);
> "0x04d1574d4eab8f3dde4d2dc7ed2c4d699d77cbbdd09167b8fffa099652ce4df00c4c6e0263eafe05007a46fdf0c8d32b11aeabcd3abbc7b2bc2bb967368a68e9c6"

getPrivateKey¶

web3.shh.getPrivateKey(id, [callback])

Returns the private key for a key pair ID.

Parameters¶

String - The key pair ID, returned by the creation functions (shh.newKeyPair and shh.addPrivateKey).
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

String - Private key on success and an error on failure.

Example¶

web3.shh.getPrivateKey('3e22b9ffc2387e18636e0a3d0c56b023264c16e78a2adcba1303cefc685e610f')
.then(console.log);
> "0x234234e22b9ffc2387e18636e0534534a3d0c56b0243567432453264c16e78a2adc"

newSymKey¶

web3.shh.newSymKey([callback])

Generates a random symmetric key and stores it under an ID, which is then returned. Will be used for encrypting and decrypting of messages where the sym key is known to both parties.

Parameters¶

Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

String - Key ID on success and an error on failure.

Example¶

web3.shh.newSymKey()
.then(console.log);
> "cec94d139ff51d7df1d228812b90c23ec1f909afa0840ed80f1e04030bb681e4"

addSymKey¶

web3.shh.addSymKey(symKey, [callback])

Stores the key, and returns its ID.

Parameters¶

String - The raw key for symmetric encryption as HEX bytes.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

String - Key ID on success and an error on failure.

Example¶

web3.shh.addSymKey('0x5e11b9ffc2387e18636e0a3d0c56b023264c16e78a2adcba1303cefc685e610f')
.then(console.log);
> "fea94d139ff51d7df1d228812b90c23ec1f909afa0840ed80f1e04030bb681e4"

generateSymKeyFromPassword¶

web3.shh.generateSymKeyFromPassword(password, [callback])

Generates the key from password, stores it, and returns its ID.

Parameters¶

String - A password to generate the sym key from.
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise<string>|undefined - Returns the Key ID as Promise or undefined if a callback is defined.

Example¶

web3.shh.generateSymKeyFromPassword('Never use this password - password!')
.then(console.log);
> "2e57b9ffc2387e18636e0a3d0c56b023264c16e78a2adcba1303cefc685e610f"

hasSymKey¶

web3.shh.hasSymKey(id, [callback])

Checks if there is a symmetric key stored with the given ID.

Parameters¶

String - The key pair ID, returned by the creation functions (shh.newSymKey, shh.addSymKey or shh.generateSymKeyFromPassword).
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Boolean - true on if the symmetric key exist in the node, false if not. Error on failure.

Example¶

web3.shh.hasSymKey('f6dcf21ed6a17bd78d8c4c63195ab997b3b65ea683705501eae82d32667adc92')
.then(console.log);
> true

getSymKey¶

web3.shh.getSymKey(id, [callback])

Returns the symmetric key associated with the given ID.

Parameters¶

String - The key pair ID, returned by the creation functions (shh.newKeyPair and shh.addPrivateKey).
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

String - The raw symmetric key on success and an error on failure.

Example¶

web3.shh.getSymKey('af33b9ffc2387e18636e0a3d0c56b023264c16e78a2adcba1303cefc685e610f')
.then(console.log);
> "0xa82a520aff70f7a989098376e48ec128f25f767085e84d7fb995a9815eebff0a"

deleteSymKey¶

web3.shh.deleteSymKey(id, [callback])

Deletes the symmetric key associated with the given ID.

Parameters¶

String - The key pair ID, returned by the creation functions (shh.newKeyPair and shh.addPrivateKey).
Function - (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Boolean - true on if the symmetric key was deleted, error on failure.

Example¶

web3.shh.deleteSymKey('bf31b9ffc2387e18636e0a3d0c56b023264c16e78a2adcba1303cefc685e610f')
.then(console.log);
> true

post¶

web3.shh.post(object [, callback])

This method should be called, when we want to post whisper a message to the network.

Parameters¶

Object - The post object:
- symKeyID - String (optional): ID of symmetric key for message encryption (Either symKeyID or pubKey must be present. Can not be both.).
- pubKey - String (optional): The public key for message encryption (Either symKeyID or pubKey must be present. Can not be both.).
- sig - String (optional): The ID of the signing key.
- ttl - Number: Time-to-live in seconds.
- topic - String: 4 Bytes (mandatory when key is symmetric): Message topic.
- payload - String: The payload of the message to be encrypted.
- padding - Number (optional): Padding (byte array of arbitrary length).
- powTime - Number (optional)?: Maximal time in seconds to be spent on proof of work.
- powTarget - Number (optional)?: Minimal PoW target required for this message.
- targetPeer - Number (optional): Peer ID (for peer-to-peer message only).
callback - Function: (optional) Optional callback, returns an error object as first parameter and the result as second.

Returns¶

Promise - returns a promise. Upon success, the then function will be passed a string representing the hash of the sent message. On error, the catch function will be passed a string containing the reason for the error.

Example¶

var identities = [];
var subscription = null;

Promise.all([
    web3.shh.newSymKey().then((id) => {identities.push(id);}),
    web3.shh.newKeyPair().then((id) => {identities.push(id);})

]).then(() => {

    // will receive also its own message send, below
    subscription = shh.subscribe("messages", {
        symKeyID: identities[0],
        topics: ['0xffaadd11']
    }).on('data', console.log);

}).then(() => {
   web3.shh.post({
        symKeyID: identities[0], // encrypts using the sym key ID
        sig: identities[1], // signs the message using the keyPair ID
        ttl: 10,
        topic: '0xffaadd11',
        payload: '0xffffffdddddd1122',
        powTime: 3,
        powTarget: 0.5
    }).then(h => console.log(`Message with hash ${h} was successfuly sent`))
    .catch(err => console.log("Error: ", err));
});

subscribe¶

web3.shh.subscribe('messages', options [, callback])

Subscribe for incoming whisper messages.

Parameters¶

"messages" - String: Type of the subscription.
Object - The subscription options:
- symKeyID - String: ID of symmetric key for message decryption.
- privateKeyID - String: ID of private (asymmetric) key for message decryption.
- sig - String (optional): Public key of the signature, to verify.
- topics- Array (optional when "privateKeyID" key is given): Filters messages by this topic(s). Each topic must be a 4 bytes HEX string.
- minPow - Number (optional): Minimal PoW requirement for incoming messages.
- allowP2P - Boolean (optional): Indicates if this filter allows processing of direct peer-to-peer messages (which are not to be forwarded any further, because they might be expired). This might be the case in some very rare cases, e.g. if you intend to communicate to MailServers, etc.
callback - Function: (optional) Optional callback, returns an error object as first parameter and the result as second. Will be called for each incoming subscription, and the subscription itself as 3 parameter.

Notification Returns¶

Object - The incoming message:

hash - String: Hash of the enveloped message.

sig - String: Public key which signed this message.

recipientPublicKey - String: The recipients public key.

timestamp - String: Unix timestamp of the message genertion.

ttl - Number: Time-to-live in seconds.

topic - String: 4 Bytes HEX string message topic.

payload - String: Decrypted payload.

padding - Number: Optional padding (byte array of arbitrary length).

pow - Number: Proof of work value.

Example¶

web3.shh.subscribe('messages', {
    symKeyID: 'bf31b9ffc2387e18636e0a3d0c56b023264c16e78a2adcba1303cefc685e610f',
    sig: '0x04d1574d4eab8f3dde4d2dc7ed2c4d699d77cbbdd09167b8fffa099652ce4df00c4c6e0263eafe05007a46fdf0c8d32b11aeabcd3abbc7b2bc2bb967368a68e9c6',
    ttl: 20,
    topics: ['0xffddaa11'],
    minPow: 0.8,
}, function(error, message, subscription){

    console.log(message);
    > {
        "hash": "0x4158eb81ad8e30cfcee67f20b1372983d388f1243a96e39f94fd2797b1e9c78e",
        "padding": "0xc15f786f34e5cef0fef6ce7c1185d799ecdb5ebca72b3310648c5588db2e99a0d73301c7a8d90115a91213f0bc9c72295fbaf584bf14dc97800550ea53577c9fb57c0249caeb081733b4e605cdb1a6011cee8b6d8fddb972c2b90157e23ba3baae6c68d4f0b5822242bb2c4cd821b9568d3033f10ec1114f641668fc1083bf79ebb9f5c15457b538249a97b22a4bcc4f02f06dec7318c16758f7c008001c2e14eba67d26218ec7502ad6ba81b2402159d7c29b068b8937892e3d4f0d4ad1fb9be5e66fb61d3d21a1c3163bce74c0a9d16891e2573146aa92ecd7b91ea96a6987ece052edc5ffb620a8987a83ac5b8b6140d8df6e92e64251bf3a2cec0cca",
        "payload": "0xdeadbeaf",
        "pow": 0.5371803278688525,
        "recipientPublicKey": null,
        "sig": null,
        "timestamp": 1496991876,
        "topic": "0x01020304",
        "ttl": 50
    }
})
// or
.on('data', function(message){ ... });

clearSubscriptions¶

web3.shh.clearSubscriptions()

Resets subscriptions.

주석

This will not reset subscriptions from other packages like web3-eth, as they use their own requestManager.

Parameters¶

Boolean: If true it keeps the "syncing" subscription.

Returns¶

Boolean

Example¶

web3.shh.subscribe('messages', {...} ,function(){ ... });

...

web3.shh.clearSubscriptions();

newMessageFilter¶

web3.shh.newMessageFilter(options)

Create a new filter within the node. This filter can be used to poll for new messages that match the set of criteria.

Parameters¶

Object: See web3.shh.subscribe() options for details.

Returns¶

String: The filter ID.

Example¶

web3.shh.newMessageFilter()
.then(console.log);
> "2b47fbafb3cce24570812a82e6e93cd9e2551bbc4823f6548ff0d82d2206b326"

deleteMessageFilter¶

web3.shh.deleteMessageFilter(id)

Deletes a message filter in the node.

Parameters¶

String: The filter ID created with shh.newMessageFilter().

Returns¶

Boolean: true on success, error on failure.

Example¶

web3.shh.deleteMessageFilter('2b47fbafb3cce24570812a82e6e93cd9e2551bbc4823f6548ff0d82d2206b326')
.then(console.log);
> true

getFilterMessages¶

web3.shh.getFilterMessages(id)

Retrieve messages that match the filter criteria and are received between the last time this function was called and now.

Parameters¶

String: The filter ID created with shh.newMessageFilter().

Returns¶

Array: Returns an array of message objects like web3.shh.subscribe() notification returns

Example¶

web3.shh.getFilterMessages('2b47fbafb3cce24570812a82e6e93cd9e2551bbc4823f6548ff0d82d2206b326')
.then(console.log);
> [{
    "hash": "0x4158eb81ad8e30cfcee67f20b1372983d388f1243a96e39f94fd2797b1e9c78e",
    "padding": "0xc15f786f34e5cef0fef6ce7c1185d799ecdb5ebca72b3310648c5588db2e99a0d73301c7a8d90115a91213f0bc9c72295fbaf584bf14dc97800550ea53577c9fb57c0249caeb081733b4e605cdb1a6011cee8b6d8fddb972c2b90157e23ba3baae6c68d4f0b5822242bb2c4cd821b9568d3033f10ec1114f641668fc1083bf79ebb9f5c15457b538249a97b22a4bcc4f02f06dec7318c16758f7c008001c2e14eba67d26218ec7502ad6ba81b2402159d7c29b068b8937892e3d4f0d4ad1fb9be5e66fb61d3d21a1c3163bce74c0a9d16891e2573146aa92ecd7b91ea96a6987ece052edc5ffb620a8987a83ac5b8b6140d8df6e92e64251bf3a2cec0cca",
    "payload": "0xdeadbeaf",
    "pow": 0.5371803278688525,
    "recipientPublicKey": null,
    "sig": null,
    "timestamp": 1496991876,
    "topic": "0x01020304",
    "ttl": 50
},{...}]

web3.utils¶

해당 package 는 Ethereum dapps 와 다른 web3.js packages 를 위한 utility functions 를 제공한다.

Bloom Filters¶

bloom filters 란?¶

Bloom Filter 는 set membership 의 신속한 확인을 위한 확률적이고 공간 효율적인 데이터 구조이다. 그것은 아직 당신에게 큰 의미가 없을 것이다. 그렇기에 Bloom Filters 가 어떻게 사용될 수 있는지 알아본다.

우리가 매우 큰 데이터 세트를 가지고있고, 어떠한 요소가 현재 그 세트 안에 있는지 빠르게 테스트하길 바란다고 가정해보자. 확인을 위한 단순한 방법은 요소가 존재하는지 세트에 query 하는 것일 수도 있다. 그 방법은 데이터 세트가 상대적으로 작다면 아마 괜찮을 것이다. 그러나 만약 데이터 세트가 매우 크다면, 이러한 탐색은 시간이 걸릴 것이다. 다행이도, 우리는 Ethereum 세계에서 속도를 높일 수 있는 방법을 가지고 있다!

Bloom Filter 는 이러한 방법 중 하나이다. Bloom Filter 의 기본 개념은 데이터 세트로 들어가는 각각의 새로운 요소를 해시하고, 이 해시로 부터 특정 비트를 가져온 다음, 그 비트를 사용하여 고정 크기 비트 배열의 일부를 채우는 것이다(예: 특정 비트를 1로 설정). 이 비트 배열을 Bloom Filter 라고 한다.

나중에 어떤 요소가 세트에 있는지 확인하고 싶을 때, 우리는 단순히 요소를 해시하고 적절한 비트가 Bloom Filter 에 있는지 확인한다. 비트 중 하나 이상이 0이면 해당 요소가 데이터 집합에 없는 것이 확실하다! 모든 비트가 1이면 요소가 데이터 집합에 있을 수 있지만 실제로 데이터 베이스를 query 하여 확인해야 한다. 그래서 우리는 잘못된 긍정 결과를 얻을 수도 있지만, 결코 잘못된 부정 결과는 얻을 수 없을 것이다. 이 것은 우리가 해야하는 데이터베이스의 query 수를 크게 줄일 수 있다.

실제 사례

이 것이 유용한 Ethereum 실제 사례의 예로 가능한 한 실시간에 가깝게 유지되도록 모든 새로운 블록에서 사용자 균형을 업데이트 하려는 경우를 들 수 있다. 모든 새로운 블록에 Bloom Filter 를 사용하지 않으면 사용자가 블록 내에서 어떠한 활동도 하지 않더라도 균형을 맞춰야 할 것이다. 그러나 블록의 logBlooms 를 사용하면 더 느린 작업을 수행하기 전에 사용자들의 ethereum 주소에 대해 Bloom Filter 를 테스트 할 수 있으며, 이는 해당 ethereum 주소가 해당 블록 내에 있는 경우에만 추가 작업을 수행하므로(잘못된 긍정 결과를 최소화하여) 통신량을 크게 줄일 수 있다. 이 것은 당신의 앱에 매우 효과적일 것이다.

기능¶

주석

이슈 제기는 여기

randomHex¶

web3.utils.randomHex(size)

주어진 바이트 크기에서 의사 난수로 강력하게 암호화된 HEX 문자열을 생성하기 위한 randomHex 라이브러리.

parameters¶

size - Number: HEX 문자열에 대한 바이트 크기, 예를 들어 ``32``는 "0x"로 미리 만들어진 64자의 HEX 문자열을 32바이트로 만든다.

Returns¶

String: 무작위로 생성된 HEX 문자열.

예제¶

web3.utils.randomHex(32)
> "0xa5b9d60f32436310afebcfda832817a68921beb782fabf7915cc0460b443116a"

web3.utils.randomHex(4)
> "0x6892ffc6"

web3.utils.randomHex(2)
> "0x99d6"

web3.utils.randomHex(1)
> "0x9a"

web3.utils.randomHex(0)
> "0x"

_¶

web3.utils._()

많은 편리한 JavaScript 기능들을 위한 underscore 라이브러리

세부정보 underscore API reference

예제¶

var _ = web3.utils._;

_.union([1,2],[3]);
> [1,2,3]

_.each({my: 'object'}, function(value, key){ ... })

...

BN¶

web3.utils.BN(mixed)

The BN.js library for calculating with big numbers in JavaScript. See the BN.js documentation for details.

주석

For safe conversion of many types, incl BigNumber.js use utils.toBN

Parameters¶

mixed - String|Number: A number, number string or HEX string to convert to a BN object.

Returns¶

Object: The BN.js instance.

Example¶

var BN = web3.utils.BN;

new BN(1234).toString();
> "1234"

new BN('1234').add(new BN('1')).toString();
> "1235"

new BN('0xea').toString();
> "234"

isBN¶

web3.utils.isBN(bn)

Checks if a given value is a BN.js instance.

Parameters¶

bn - Object: An BN.js instance.

Returns¶

Boolean

Example¶

var number = new BN(10);

web3.utils.isBN(number);
> true

isBigNumber¶

web3.utils.isBigNumber(bignumber)

Checks if a given value is a BigNumber.js instance.

Parameters¶

bignumber - Object: A BigNumber.js instance.

Returns¶

Boolean

Example¶

var number = new BigNumber(10);

web3.utils.isBigNumber(number);
> true

sha3¶

web3.utils.sha3(string)
web3.utils.keccak256(string) // ALIAS

Will calculate the sha3 of the input.

주석

To mimic the sha3 behaviour of solidity use soliditySha3

Parameters¶

string - String: A string to hash.

Returns¶

String: the result hash.

Example¶

web3.utils.sha3('234'); // taken as string
> "0xc1912fee45d61c87cc5ea59dae311904cd86b84fee17cc96966216f811ce6a79"

web3.utils.sha3(new BN('234'));
> "0xbc36789e7a1e281436464229828f817d6612f7b477d66591ff96a9e064bcc98a"

web3.utils.sha3(234);
> null // can't calculate the has of a number

web3.utils.sha3(0xea); // same as above, just the HEX representation of the number
> null

web3.utils.sha3('0xea'); // will be converted to a byte array first, and then hashed
> "0x2f20677459120677484f7104c76deb6846a2c071f9b3152c103bb12cd54d1a4a"

sha3Raw¶

web3.utils.sha3Raw(string)

Will calculate the sha3 of the input but does return the hash value instead of null if for example a empty string is passed.

주석

Further details about this function can be seen here sha3

soliditySha3¶

web3.utils.soliditySha3(param1 [, param2, ...])

Will calculate the sha3 of given input parameters in the same way solidity would. This means arguments will be ABI converted and tightly packed before being hashed.

Parameters¶

paramX - Mixed: Any type, or an object with {type: 'uint', value: '123456'} or {t: 'bytes', v: '0xfff456'}. Basic types are autodetected as follows:
- String non numerical UTF-8 string is interpreted as string.
- String|Number|BN|HEX positive number is interpreted as uint256.
- String|Number|BN negative number is interpreted as int256.
- Boolean as bool.
- String HEX string with leading 0x is interpreted as bytes.
- HEX HEX number representation is interpreted as uint256.

Returns¶

String: the result hash.

Example¶

web3.utils.soliditySha3('234564535', '0xfff23243', true, -10);
// auto detects:        uint256,      bytes,     bool,   int256
> "0x3e27a893dc40ef8a7f0841d96639de2f58a132be5ae466d40087a2cfa83b7179"


web3.utils.soliditySha3('Hello!%'); // auto detects: string
> "0x661136a4267dba9ccdf6bfddb7c00e714de936674c4bdb065a531cf1cb15c7fc"


web3.utils.soliditySha3('234'); // auto detects: uint256
> "0x61c831beab28d67d1bb40b5ae1a11e2757fa842f031a2d0bc94a7867bc5d26c2"

web3.utils.soliditySha3(0xea); // same as above
> "0x61c831beab28d67d1bb40b5ae1a11e2757fa842f031a2d0bc94a7867bc5d26c2"

web3.utils.soliditySha3(new BN('234')); // same as above
> "0x61c831beab28d67d1bb40b5ae1a11e2757fa842f031a2d0bc94a7867bc5d26c2"

web3.utils.soliditySha3({type: 'uint256', value: '234'})); // same as above
> "0x61c831beab28d67d1bb40b5ae1a11e2757fa842f031a2d0bc94a7867bc5d26c2"

web3.utils.soliditySha3({t: 'uint', v: new BN('234')})); // same as above
> "0x61c831beab28d67d1bb40b5ae1a11e2757fa842f031a2d0bc94a7867bc5d26c2"


web3.utils.soliditySha3('0x407D73d8a49eeb85D32Cf465507dd71d507100c1');
> "0x4e8ebbefa452077428f93c9520d3edd60594ff452a29ac7d2ccc11d47f3ab95b"

web3.utils.soliditySha3({t: 'bytes', v: '0x407D73d8a49eeb85D32Cf465507dd71d507100c1'});
> "0x4e8ebbefa452077428f93c9520d3edd60594ff452a29ac7d2ccc11d47f3ab95b" // same result as above


web3.utils.soliditySha3({t: 'address', v: '0x407D73d8a49eeb85D32Cf465507dd71d507100c1'});
> "0x4e8ebbefa452077428f93c9520d3edd60594ff452a29ac7d2ccc11d47f3ab95b" // same as above, but will do a checksum check, if its multi case


web3.utils.soliditySha3({t: 'bytes32', v: '0x407D73d8a49eeb85D32Cf465507dd71d507100c1'});
> "0x3c69a194aaf415ba5d6afca734660d0a3d45acdc05d54cd1ca89a8988e7625b4" // different result as above


web3.utils.soliditySha3({t: 'string', v: 'Hello!%'}, {t: 'int8', v:-23}, {t: 'address', v: '0x85F43D8a49eeB85d32Cf465507DD71d507100C1d'});
> "0xa13b31627c1ed7aaded5aecec71baf02fe123797fffd45e662eac8e06fbe4955"

soliditySha3Raw¶

web3.utils.soliditySha3Raw(param1 [, param2, ...])

Will calculate the sha3 of given input parameters in the same way solidity would. This means arguments will be ABI converted and tightly packed before being hashed. The difference between this function and the soliditySha3 function is that it will return the hash value instead of null if for example a empty string is given.

주석

Further details about this function can be seen here soliditySha3

isHex¶

web3.utils.isHex(hex)

Checks if a given string is a HEX string.

Parameters¶

hex - String|HEX: The given HEX string.

Returns¶

Boolean

Example¶

web3.utils.isHex('0xc1912');
> true

web3.utils.isHex(0xc1912);
> true

web3.utils.isHex('c1912');
> true

web3.utils.isHex(345);
> true // this is tricky, as 345 can be a a HEX representation or a number, be careful when not having a 0x in front!

web3.utils.isHex('0xZ1912');
> false

web3.utils.isHex('Hello');
> false

isHexStrict¶

web3.utils.isHexStrict(hex)

Checks if a given string is a HEX string. Difference to web3.utils.isHex() is that it expects HEX to be prefixed with 0x.

Parameters¶

hex - String|HEX: The given HEX string.

Returns¶

Boolean

Example¶

web3.utils.isHexStrict('0xc1912');
> true

web3.utils.isHexStrict(0xc1912);
> false

web3.utils.isHexStrict('c1912');
> false

web3.utils.isHexStrict(345);
> false // this is tricky, as 345 can be a a HEX representation or a number, be careful when not having a 0x in front!

web3.utils.isHexStrict('0xZ1912');
> false

web3.utils.isHex('Hello');
> false

isAddress¶

web3.utils.isAddress(address)

Checks if a given string is a valid Ethereum address. It will also check the checksum, if the address has upper and lowercase letters.

Parameters¶

address - String: An address string.

Returns¶

Boolean

Example¶

web3.utils.isAddress('0xc1912fee45d61c87cc5ea59dae31190fffff232d');
> true

web3.utils.isAddress('c1912fee45d61c87cc5ea59dae31190fffff232d');
> true

web3.utils.isAddress('0XC1912FEE45D61C87CC5EA59DAE31190FFFFF232D');
> true // as all is uppercase, no checksum will be checked

web3.utils.isAddress('0xc1912fEE45d61C87Cc5EA59DaE31190FFFFf232d');
> true

web3.utils.isAddress('0xC1912fEE45d61C87Cc5EA59DaE31190FFFFf232d');
> false // wrong checksum

toChecksumAddress¶

web3.utils.toChecksumAddress(address)

Will convert an upper or lowercase Ethereum address to a checksum address.

Parameters¶

address - String: An address string.

Returns¶

String: The checksum address.

Example¶

web3.utils.toChecksumAddress('0xc1912fee45d61c87cc5ea59dae31190fffff232d');
> "0xc1912fEE45d61C87Cc5EA59DaE31190FFFFf232d"

web3.utils.toChecksumAddress('0XC1912FEE45D61C87CC5EA59DAE31190FFFFF232D');
> "0xc1912fEE45d61C87Cc5EA59DaE31190FFFFf232d" // same as above

checkAddressChecksum¶

web3.utils.checkAddressChecksum(address)

Checks the checksum of a given address. Will also return false on non-checksum addresses.

Parameters¶

address - String: An address string.

Returns¶

Boolean: true when the checksum of the address is valid, false if its not a checksum address, or the checksum is invalid.

Example¶

web3.utils.checkAddressChecksum('0xc1912fEE45d61C87Cc5EA59DaE31190FFFFf232d');
> true

toHex¶

web3.utils.toHex(mixed)

Will auto convert any given value to HEX. Number strings will interpreted as numbers. Text strings will be interpreted as UTF-8 strings.

Parameters¶

mixed - String|Number|BN|BigNumber: The input to convert to HEX.

Returns¶

String: The resulting HEX string.

Example¶

web3.utils.toHex('234');
> "0xea"

web3.utils.toHex(234);
> "0xea"

web3.utils.toHex(new BN('234'));
> "0xea"

web3.utils.toHex(new BigNumber('234'));
> "0xea"

web3.utils.toHex('I have 100€');
> "0x49206861766520313030e282ac"

toBN¶

web3.utils.toBN(number)

Will safely convert any given value (including BigNumber.js instances) into a BN.js instance, for handling big numbers in JavaScript.

주석

For just the BN.js class use utils.BN

Parameters¶

number - String|Number|HEX: Number to convert to a big number.

Returns¶

Object: The BN.js instance.

Example¶

web3.utils.toBN(1234).toString();
> "1234"

web3.utils.toBN('1234').add(web3.utils.toBN('1')).toString();
> "1235"

web3.utils.toBN('0xea').toString();
> "234"

hexToNumberString¶

web3.utils.hexToNumberString(hex)

Returns the number representation of a given HEX value as a string.

Parameters¶

hexString - String|HEX: A string to hash.

Returns¶

String: The number as a string.

Example¶

web3.utils.hexToNumberString('0xea');
> "234"

hexToNumber¶

web3.utils.hexToNumber(hex)
web3.utils.toDecimal(hex) // ALIAS, deprecated

Returns the number representation of a given HEX value.

주석

This is not useful for big numbers, rather use utils.toBN instead.

Parameters¶

hexString - String|HEX: A string to hash.

Returns¶

Number

Example¶

web3.utils.hexToNumber('0xea');
> 234

numberToHex¶

web3.utils.numberToHex(number)
web3.utils.fromDecimal(number) // ALIAS, deprecated

Returns the HEX representation of a given number value.

Parameters¶

number - String|Number|BN|BigNumber: A number as string or number.

Returns¶

String: The HEX value of the given number.

Example¶

web3.utils.numberToHex('234');
> '0xea'

hexToUtf8¶

web3.utils.hexToUtf8(hex)
web3.utils.hexToString(hex) // ALIAS
web3.utils.toUtf8(hex) // ALIAS, deprecated

Returns the UTF-8 string representation of a given HEX value.

Parameters¶

hex - String: A HEX string to convert to a UTF-8 string.

Returns¶

String: The UTF-8 string.

Example¶

web3.utils.hexToUtf8('0x49206861766520313030e282ac');
> "I have 100€"

hexToAscii¶

web3.utils.hexToAscii(hex)
web3.utils.toAscii(hex) // ALIAS, deprecated

Returns the ASCII string representation of a given HEX value.

Parameters¶

hex - String: A HEX string to convert to a ASCII string.

Returns¶

String: The ASCII string.

Example¶

web3.utils.hexToAscii('0x4920686176652031303021');
> "I have 100!"

utf8ToHex¶

web3.utils.utf8ToHex(string)
web3.utils.stringToHex(string) // ALIAS
web3.utils.fromUtf8(string) // ALIAS, deprecated

Returns the HEX representation of a given UTF-8 string.

Parameters¶

string - String: A UTF-8 string to convert to a HEX string.

Returns¶

String: The HEX string.

Example¶

web3.utils.utf8ToHex('I have 100€');
> "0x49206861766520313030e282ac"

asciiToHex¶

web3.utils.asciiToHex(string)
web3.utils.fromAscii(string) // ALIAS, deprecated

Returns the HEX representation of a given ASCII string.

Parameters¶

string - String: A ASCII string to convert to a HEX string.

Returns¶

String: The HEX string.

Example¶

web3.utils.asciiToHex('I have 100!');
> "0x4920686176652031303021"

hexToBytes¶

web3.utils.hexToBytes(hex)

Returns a byte array from the given HEX string.

Parameters¶

hex - String|HEX: A HEX to convert.

Returns¶

Array: The byte array.

Example¶

web3.utils.hexToBytes('0x000000ea');
> [ 0, 0, 0, 234 ]

web3.utils.hexToBytes(0x000000ea);
> [ 234 ]

bytesToHex¶

web3.utils.bytesToHex(byteArray)

Returns a HEX string from a byte array.

Parameters¶

byteArray - Array: A byte array to convert.

Returns¶

String: The HEX string.

Example¶

web3.utils.bytesToHex([ 72, 101, 108, 108, 111, 33, 36 ]);
> "0x48656c6c6f2125"

toWei¶

web3.utils.toWei(number [, unit])

Converts any ether value value into wei.

주석

"wei" are the smallest ethere unit, and you should always make calculations in wei and convert only for display reasons.

Parameters¶

number - String|BN: The value.
unit - String (optional, defaults to "ether"): The ether to convert from. Possible units are:
- noether: '0'
- wei: '1'
- kwei: '1000'
- Kwei: '1000'
- babbage: '1000'
- femtoether: '1000'
- mwei: '1000000'
- Mwei: '1000000'
- lovelace: '1000000'
- picoether: '1000000'
- gwei: '1000000000'
- Gwei: '1000000000'
- shannon: '1000000000'
- nanoether: '1000000000'
- nano: '1000000000'
- szabo: '1000000000000'
- microether: '1000000000000'
- micro: '1000000000000'
- finney: '1000000000000000'
- milliether: '1000000000000000'
- milli: '1000000000000000'
- ether: '1000000000000000000'
- kether: '1000000000000000000000'
- grand: '1000000000000000000000'
- mether: '1000000000000000000000000'
- gether: '1000000000000000000000000000'
- tether: '1000000000000000000000000000000'

Returns¶

String|BN: If a string is given it returns a number string, otherwise a BN.js instance.

Example¶

web3.utils.toWei('1', 'ether');
> "1000000000000000000"

web3.utils.toWei('1', 'finney');
> "1000000000000000"

web3.utils.toWei('1', 'szabo');
> "1000000000000"

web3.utils.toWei('1', 'shannon');
> "1000000000"

fromWei¶

web3.utils.fromWei(number [, unit])

Converts any wei value into a ether value.

주석

"wei" are the smallest ethere unit, and you should always make calculations in wei and convert only for display reasons.

Parameters¶

number - String|BN: The value in wei.
unit - String (optional, defaults to "ether"): The ether to convert to. Possible units are:
- noether: '0'
- wei: '1'
- kwei: '1000'
- Kwei: '1000'
- babbage: '1000'
- femtoether: '1000'
- mwei: '1000000'
- Mwei: '1000000'
- lovelace: '1000000'
- picoether: '1000000'
- gwei: '1000000000'
- Gwei: '1000000000'
- shannon: '1000000000'
- nanoether: '1000000000'
- nano: '1000000000'
- szabo: '1000000000000'
- microether: '1000000000000'
- micro: '1000000000000'
- finney: '1000000000000000'
- milliether: '1000000000000000'
- milli: '1000000000000000'
- ether: '1000000000000000000'
- kether: '1000000000000000000000'
- grand: '1000000000000000000000'
- mether: '1000000000000000000000000'
- gether: '1000000000000000000000000000'
- tether: '1000000000000000000000000000000'

Returns¶

String: It always returns a string number.

Example¶

web3.utils.fromWei('1', 'ether');
> "0.000000000000000001"

web3.utils.fromWei('1', 'finney');
> "0.000000000000001"

web3.utils.fromWei('1', 'szabo');
> "0.000000000001"

web3.utils.fromWei('1', 'shannon');
> "0.000000001"

unitMap¶

web3.utils.unitMap

Shows all possible ether value and their amount in wei.

Return value¶

Object with the following properties:
- noether: '0'
- wei: '1'
- kwei: '1000'
- Kwei: '1000'
- babbage: '1000'
- femtoether: '1000'
- mwei: '1000000'
- Mwei: '1000000'
- lovelace: '1000000'
- picoether: '1000000'
- gwei: '1000000000'
- Gwei: '1000000000'
- shannon: '1000000000'
- nanoether: '1000000000'
- nano: '1000000000'
- szabo: '1000000000000'
- microether: '1000000000000'
- micro: '1000000000000'
- finney: '1000000000000000'
- milliether: '1000000000000000'
- milli: '1000000000000000'
- ether: '1000000000000000000'
- kether: '1000000000000000000000'
- grand: '1000000000000000000000'
- mether: '1000000000000000000000000'
- gether: '1000000000000000000000000000'
- tether: '1000000000000000000000000000000'

Example¶

web3.utils.unitMap
> {
    noether: '0',
    wei:        '1',
    kwei:       '1000',
    Kwei:       '1000',
    babbage:    '1000',
    femtoether: '1000',
    mwei:       '1000000',
    Mwei:       '1000000',
    lovelace:   '1000000',
    picoether:  '1000000',
    gwei:       '1000000000',
    Gwei:       '1000000000',
    shannon:    '1000000000',
    nanoether:  '1000000000',
    nano:       '1000000000',
    szabo:      '1000000000000',
    microether: '1000000000000',
    micro:      '1000000000000',
    finney:     '1000000000000000',
    milliether: '1000000000000000',
    milli:      '1000000000000000',
    ether:      '1000000000000000000',
    kether:     '1000000000000000000000',
    grand:      '1000000000000000000000',
    mether:     '1000000000000000000000000',
    gether:     '1000000000000000000000000000',
    tether:     '1000000000000000000000000000000'
}

padLeft¶

web3.utils.padLeft(string, characterAmount [, sign])
web3.utils.leftPad(string, characterAmount [, sign]) // ALIAS

Adds a padding on the left of a string, Useful for adding paddings to HEX strings.

Parameters¶

string - String: The string to add padding on the left.
characterAmount - Number: The number of characters the total string should have.
sign - String (optional): The character sign to use, defaults to "0".

Returns¶

String: The padded string.

Example¶

web3.utils.padLeft('0x3456ff', 20);
> "0x000000000000003456ff"

web3.utils.padLeft(0x3456ff, 20);
> "0x000000000000003456ff"

web3.utils.padLeft('Hello', 20, 'x');
> "xxxxxxxxxxxxxxxHello"

padRight¶

web3.utils.padRight(string, characterAmount [, sign])
web3.utils.rightPad(string, characterAmount [, sign]) // ALIAS

Adds a padding on the right of a string, Useful for adding paddings to HEX strings.

Parameters¶

string - String: The string to add padding on the right.
characterAmount - Number: The number of characters the total string should have.
sign - String (optional): The character sign to use, defaults to "0".

Returns¶

String: The padded string.

Example¶

web3.utils.padRight('0x3456ff', 20);
> "0x3456ff00000000000000"

web3.utils.padRight(0x3456ff, 20);
> "0x3456ff00000000000000"

web3.utils.padRight('Hello', 20, 'x');
> "Helloxxxxxxxxxxxxxxx"

toTwosComplement¶

web3.utils.toTwosComplement(number)

Converts a negative numer into a two's complement.

Parameters¶

number - Number|String|BigNumber: The number to convert.

Returns¶

String: The converted hex string.

Example¶

web3.utils.toTwosComplement('-1');
> "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"

web3.utils.toTwosComplement(-1);
> "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"

web3.utils.toTwosComplement('0x1');
> "0x0000000000000000000000000000000000000000000000000000000000000001"

web3.utils.toTwosComplement(-15);
> "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1"

web3.utils.toTwosComplement('-0x1');
> "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"