# RPC API

ViteJ has wrapped most of Vite RPC APIs. This page describes how to use them in your code.

See RPC API Documentation to know more information about Vite RPC API.

# How to Call RPC API

# Create ViteJ Object

At beginning, you should create a ViteJ object and choose how to connect to a node.

Use HTTP:

// default url is http://127.0.0.1:48132
Vitej vitej0 = new Vitej(new HttpService());
// but you can specify a different one
Vitej vitej1 = new Vitej(new HttpService("http://127.0.0.1:48132"));
// specify http url and http client
Vitej vitej2 = new Vitej(new HttpService("http://127.0.0.1:48132", new OkHttpClient.Builder().build()));
// use given private key
KeyPair keyPair = new Wallet(Arrays.asList("network","north","tell","potato","predict","almost","wonder","spirit","wheel","smile","disease","bonus","round","flock","pole","review","music","oven","clarify","exclude","loyal","episode","image","notable")).deriveKeyPair();
Vitej vitej3 = new Vitej(new HttpService(), keyPair);

Use WebSocket:

// default url is ws://127.0.0.1:41420
WebSocketService ws0 = new WebSocketService();
ws.connect();
Vitej vitej = new Vitej(ws);
// but you can specify a different one
WebSocketService ws1 = new WebSocketService("ws://127.0.0.1:41420");
ws.connect();
Vitej vitej = new Vitej(ws);
// specify websocket url and http client
WebSocketService ws2 = new WebSocketService("ws://127.0.0.1:41420", new OkHttpClient.Builder().build());
ws.connect();
Vitej vitej = new Vitej(ws);
// use given private key
WebSocketService ws3 = new WebSocketService();
ws.connect();
KeyPair keyPair = new Wallet(Arrays.asList("network","north","tell","potato","predict","almost","wonder","spirit","wheel","smile","disease","bonus","round","flock","pole","review","music","oven","clarify","exclude","loyal","episode","image","notable")).deriveKeyPair();
Vitej vitej = new Vitej(ws, keyPair);

# Call RPC API

# RPC Request

Request JSON object (JSON-RPC 2.0)

  • jsonrpc : String Version id. must be '2.0'
  • id : long Request id
  • method : String Method name
  • params : List<Object> Parameter list
{
	"jsonrpc": "2.0",
	"id": 1,
	"method": "ledger_getLatestSnapshotHash",
	"params": []
}

# RPC Response

Response JSON object (JSON-RPC 2.0)

  • id : long Response ID, have the same value with request id
  • jsonrpc : String Version id. must be '2.0'
  • result : Object Response result
  • error : Error message
    • code : int Error code
    • message : String Description
{
    "jsonrpc": "2.0",
    "id": 1,
    "result": "67f7ee751968a832d7d776aad6de3ca9b58f37c8c4bf8442a935f891a850d8b1"
}

# Make the Call

Synchronous method

AccountBlocksResponse response = vitej.getAccountBlocksByAddress(
        new Address("vite_0996e651f3885e6e6b83dfba8caa095ff7aa248e4a429db7bd"), 0, 10
    ).send();
List<AccountBlock> accountBlockList = response.getResult();

Asynchronous method

CompletableFuture<AccountBlocksResponse> future = vitej.getAccountBlocksByAddress(
        new Address("vite_0996e651f3885e6e6b83dfba8caa095ff7aa248e4a429db7bd"), 0, 10
).sendAsync();
AccountBlocksResponse response = future.get();
List<AccountBlock> accountBlockList = response.getResult();

# RPC API Wrapper

# Send Transaction

Sending a transaction (by sendTransaction method) includes the following steps :

  1. Check transaction object. Fill in default value if required parameters are not present;
  2. Calculate quota consumption. If the available quota of the account is insufficient and having autoPoW = true , do a PoW puzzle to get temporary quota;
  3. Create transaction hash, then sign the transaction.

Module Required

Make sure util is configured in PublicModules in node_config.json on your node when autoPoW = true .

# Send a Transfer

Vitej vitej = new Vitej(new HttpService());
KeyPair keyPair = new Wallet(Arrays.asList("network", "north", "tell", "potato", "predict", "almost", "wonder", "spirit", "wheel", "smile", "disease", "bonus", "round", "flock", "pole", "review", "music", "oven", "clarify", "exclude", "loyal", "episode", "image", "notable")).deriveKeyPair();
Request<?, EmptyResponse> request = vitej.sendTransaction(
        // key used to sign the transaction
        keyPair,
        // transaction information
        new TransactionParams()
                // transaction type, optional. Default is SEND_CALL
                .setBlockType(EBlockType.SEND_CALL.getValue())
                // recipient address. must present
                .setToAddress(new Address("vite_098dfae02679a4ca05a4c8bf5dd00a8757f0c622bfccce7d68"))
                // transfer amount, optional. Default is 0
                .setAmount(BigInteger.valueOf(1))
                // transfer token id, optional. Default token is VITE
                .setTokenId(CommonConstants.VITE_TOKEN_ID)
                // transaction comment, optional
                .setData("Hello".getBytes()),
        // enable/disable pow
        false);
Hash sendBlockHash = ((TransactionParams) request.getParams().get(0)).getHashRaw();
EmptyResponse response = request.send();

# Receive

In Vite, you must explicitly send out a 'Receive' transaction to receive a 'pending' transaction that was sent to you.

Vitej vitej = new Vitej(new HttpService());
KeyPair keyPair = new Wallet(Arrays.asList("network", "north", "tell", "potato", "predict", "almost", "wonder", "spirit", "wheel", "smile", "disease", "bonus", "round", "flock", "pole", "review", "music", "oven", "clarify", "exclude", "loyal", "episode", "image", "notable")).deriveKeyPair();
Request<?, EmptyResponse> request = vitej.sendTransaction(keyPair,
        new TransactionParams()
                // transaction type. must be RECEIVE
                .setBlockType(EBlockType.RECEIVE.getValue())
                // request transaction hash. must present
                .setSendBlockHash(new Hash("ef5dccd73a6ef6370bc72b56b686362fd095152e2746f21113c2015e243b5056")),
        false);
Hash receiveBlockHash = ((TransactionParams) request.getParams().get(0)).getHashRaw();
EmptyResponse response = request.send();

# Call Smart Contract

See Call Contract for detailed information

Vitej vitej = new Vitej(new HttpService());
KeyPair keyPair = new Wallet(Arrays.asList("network", "north", "tell", "potato", "predict", "almost", "wonder", "spirit", "wheel", "smile", "disease", "bonus", "round", "flock", "pole", "review", "music", "oven", "clarify", "exclude", "loyal", "episode", "image", "notable")).deriveKeyPair();
// use abi to generate binary data to call a method on contract
Abi abi = Abi.fromJson("[{\"type\":\"function\",\"name\":\"VoteForSBP\", \"inputs\":[{\"name\":\"sbpName\",\"type\":\"string\"}]}]");
byte[] callContractData = abi.encodeFunction("VoteForSBP", "Vite_SBP01");
Request<?, EmptyResponse> request = vitej.sendTransaction(
        keyPair,
        new TransactionParams()
                // transaction type. must be SEND_CALL
                .setBlockType(EBlockType.SEND_CALL.getValue())
                // smart contract address. must present
                .setToAddress(new Address("vite_0000000000000000000000000000000000000004d28108e76b"))
                // transfer amount, optional. Default is 0
                .setAmount(new BigInteger("0"))
                // transfer token id, optional. Default token is VITE
                .setTokenId(CommonConstants.VITE_TOKEN_ID)
                // data generated in above step to call contain method. If not present, no method will be called
                .setData(callContractData),
        false);
Hash sendBlockHash = ((TransactionParams) request.getParams().get(0)).getHashRaw();
EmptyResponse response = request.send();
// check result
boolean callSuccess = ProtocolUtils.checkCallContractResult(vitej, sendBlockHash);

# Create Smart Contract

See Create Contract for detailed information

Vitej vitej = new Vitej(new HttpService());
KeyPair keyPair = new Wallet(Arrays.asList("network", "north", "tell", "potato", "predict", "almost", "wonder", "spirit", "wheel", "smile", "disease", "bonus", "round", "flock", "pole", "review", "music", "oven", "clarify", "exclude", "loyal", "episode", "image", "notable")).deriveKeyPair();
// specify binary code of the contract. tips: use --bin to generate binary when compiling soliditypp source code
byte[] bytecode = BytesUtils.hexStringToBytes("6080604052348015600f57600080fd5b50604051602080608183398101806040526020811015602d57600080fd5b810190808051906020019092919050505050603580604c6000396000f3fe6080604052600080fdfea165627a7a723058208602dc0b6a1bf2e56f2160299868dc8c3f435c9af6d384858722a21906c7c0740029");
// use abi to load constructor
Abi abi = Abi.fromJson("[{\"inputs\":[{\"name\":\"i\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]");
byte[] callConstructorData = abi.encodeConstructor(BigInteger.valueOf(1));
// generate binary data. pass in 5 parameters (binary code, constructor data, response latency, random degree, quota multiplier)
byte[] createContractData = ContractUtils.getCreateContractData(bytecode, callConstructorData, 2, 1, 10);
Request<?, EmptyResponse> request = vitej.sendTransaction(
        keyPair,
        new TransactionParams()
                // transaction type. must be SEND_CREATE
                .setBlockType(EBlockType.SEND_CREATE.getValue())
                // transfer amount, optional. Default is 0
                .setAmount(new BigInteger("0"))
                // transfer token id, optional. Default token is VITE
                .setTokenId(CommonConstants.VITE_TOKEN_ID)
                // 10 VITE contract creation fee, optional. Default is 10 VITE
                .setFee(CommonConstants.CREATE_CONTRACT_FEE)
                // data generated in above step to create smart contract. must present
                .setData(createContractData),
        false);
Hash sendBlockHash = ((TransactionParams) request.getParams().get(0)).getHashRaw();
EmptyResponse response = request.send();
boolean callSuccess = ProtocolUtils.checkCallContractResult(vitej, sendBlockHash);

# Calculate PoW

'PoW' is used when obtaining temporary quota for sending one transaction. However, we highly recommend to get quota for your account by staking. See Quota API.

Vitej vitej = new Vitej(new HttpService());
PoWNonceResponse response = vitej.getPoWNonce(
        // PoW difficulty
        BigInteger.valueOf(67108863),
        // hash value. can be obtained through BlockUtils.getPoWData
        new Hash("d517e8d4dc9c676876b72ad0cbb4c45890804aa438edd1f171ffc66276202a95")
).send();
byte[] nonce = response.getNonce();

# Get Account Block List

Get a list of account blocks in descending order of block height, starting from the latest block

Vitej vitej = new Vitej(new HttpService());
AccountBlocksResponse response = vitej.getAccountBlocksByAddress(
        // address of account
        new Address("vite_0996e651f3885e6e6b83dfba8caa095ff7aa248e4a429db7bd"),
        // page index. start at 0
        0,
        // page size
        10).send();
List<AccountBlock> accountBlockList = response.getResult();

# Get Account Block (by height)

Vitej vitej = new Vitej(new HttpService());
AccountBlockResponse response = vitej.getAccountBlockByHeight(
        // address of account
        new Address("vite_0996e651f3885e6e6b83dfba8caa095ff7aa248e4a429db7bd"),
        // block height
        1L).send();
AccountBlock accountBlock = response.getResult();

# Get Account Block (by hash)

Vitej vitej = new Vitej(new HttpService());
AccountBlockResponse response = vitej.getAccountBlockByHash(
        // hash of account block
        new Hash("c4b11ff481c5476945000993816794fbc21a315901aaecb523b503c19c133154")).send();
AccountBlock accountBlock = response.getResult();

# Get Account Block (full block)

This method can be also used to return a full RS (Receive-Send) block by specifying RS block hash

Vitej vitej = new Vitej(new HttpService());
AccountBlockResponse response = vitej.getCompleteAccountBlockByHash(
        // hash of account block
        new Hash("c4b11ff481c5476945000993816794fbc21a315901aaecb523b503c19c133154")).send();
AccountBlock accountBlock = response.getResult();

# Get the Latest Account Block

Vitej vitej = new Vitej(new HttpService());
AccountBlockResponse response = vitej.getLatestAccountBlock(
        // address of account
        new Address("vite_0996e651f3885e6e6b83dfba8caa095ff7aa248e4a429db7bd")).send();
AccountBlock accountBlock = response.getResult();

# Get Account Block List (by token id)

Get a list of account blocks in which the transfers are processed in certain token

Vitej vitej = new Vitej(new HttpService());
AccountBlocksResponse response = vitej.getAccountBlocks(
        // account address. must present
        new Address("vite_0996e651f3885e6e6b83dfba8caa095ff7aa248e4a429db7bd"),
        // hash of account block to start from. If not present, use the latest account block
        new Hash("c4b11ff481c5476945000993816794fbc21a315901aaecb523b503c19c133154"),
        // token id
        CommonConstants.VITE_TOKEN_ID,
        // number of item returned. must present
        10
).send();
List<AccountBlock> accountBlockList = response.getResult();

# Get Account Info

Vitej vitej = new Vitej(new HttpService());
AccountInfoResponse response = vitej.getAccountInfoByAddress(
        // address of account
        new Address("vite_0996e651f3885e6e6b83dfba8caa095ff7aa248e4a429db7bd")
).send();
// total transaction number
Long blockCount = response.getResult().getBlockCount();
// token-balance summary
Map<TokenId, AccountInfoResponse.BalanceInfo> balanceInfoMap = response.getResult().getBalanceInfoMap();

# Get Unreceived Transaction List

Vitej vitej = new Vitej(new HttpService());
AccountBlocksResponse response = vitej.getUnreceivedBlocksByAddress(
        // account address
        new Address("vite_0996e651f3885e6e6b83dfba8caa095ff7aa248e4a429db7bd"),
        // page index. start at 0
        0,
        // page size
        10
).send();
// unreceived transaction list
List<AccountBlock> accountBlockList = response.getResult();

# Get Unreceived Transaction Summary

Vitej vitej = new Vitej(new HttpService());
AccountInfoResponse response = vitej.getUnreceivedTransactionSummaryByAddress(
        // account address
        new Address("vite_098dfae02679a4ca05a4c8bf5dd00a8757f0c622bfccce7d68")
).send();
// number of unreceived transaction
Long blockCount = response.getResult().getBlockCount();
// unreceived token-balance summary
Map<TokenId, AccountInfoResponse.BalanceInfo> balanceInfoMap = response.getResult().getBalanceInfoMap();

# Get the Latest Snapshot Block Hash

Vitej vitej = new Vitej(new HttpService());
LatestSnapshotHashResponse response = vitej.getLatestSnapshotHash().send();
Hash latestSnapshotHash = response.getHash();

# Get the Latest Snapshot Block Height

Vitej vitej = new Vitej(new HttpService());
SnapshotChainHeightResponse response = vitej.getSnapshotChainHeight().send();
Long latestSnapshotHeight = response.getHeight();

# Get the Latest Snapshot Block

Vitej vitej = new Vitej(new HttpService());
SnapshotBlockResponse response = vitej.getLatestSnapshotBlock().send();
SnapshotBlock snapshotBlock = response.getResult();

# Get Snapshot Block List

Get a list of snapshot blocks in descending order, starting at specified height

Vitej vitej = new Vitej(new HttpService());
SnapshotBlocksResponse response = vitej.getSnapshotBlocks(
        // height to start from
        100L,
        // number of item returned
        10
).send();
List<SnapshotBlock> snapshotBlock = response.getResult();

# Get Smart Contract Event Log

Vitej vitej = new Vitej(new HttpService());
VmlogsResponse response = vitej.getVmlogs(
        // hash of smart contract response block
        new Hash("d519bd49599df00b6a5992a50065af7945c4b6af269af8791cca5688f3277e37")
).send();
List<Vmlog> vmLogList = response.getResult();

# Get Smart Contract Event Log (by filter)

Vitej vitej = new Vitej(new HttpService());
// only get event log from account block height 1-10 on smart contract vite_000000000000000000000000000000000000000595292d996d
VmLogFilter filter = new VmLogFilter(new Address("vite_000000000000000000000000000000000000000595292d996d"),
        1L, 10L);
// define a topic to get event log which has two indexed fields as the value specified
filter.setTopics(Arrays.asList(
        Collections.emptyList(),
        Arrays.asList(new Hash("000000000000000000000000000000000000000000005649544520544f4b454e"), new Hash("00000000000000000000000000000000000000000000564954455820434f494e")),
        Collections.emptyList()
));
VmlogInfosResponse response = vitej.getVmlogsByFilter(
        filter
).send();
List<VmLogInfo> vmLogInfoList = response.getResult();

# Get Smart Contract Info

Vitej vitej = new Vitej(new HttpService());
ContractInfoResponse response = vitej.getContractInfo(
        new Address("vite_000000000000000000000000000000000000000595292d996d")
).send();
ContractInfo contractInfo = response.getResult();

# Call Offchain Method

Vitej vitej = new Vitej(new HttpService());
// load abi of offchain method
Abi abi = Abi.fromJson("[{\"inputs\":[],\"name\":\"getData\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"offchain\"}]");
String methodName = "getData";
// call offchain method
CallOffChainMethodResponse response = vitej.callOffChainMethod(
        // contract address
        new Address("vite_da0e4189f8155035d5b373f8f1328e43d7d70980f4fb69ff18"),
        // specify binary code of the offchain method. tips: use --bin to generate offchain binary when compiling soliditypp source code
        BytesUtils.hexStringToBytes("6080604052600436106042576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c1a34865146044576042565b005b604a6060565b6040518082815260200191505060405180910390f35b60006000600050549050606e565b9056fea165627a7a7230582098acc939ef119097e24d6b599d9dd18bb2061a9fab6ec77401def1c0a7e52ecd0029"),
        abi.encodeOffchain(methodName)
).send();
// use abi to decode result
List<?> outputList = abi.decodeOffchainOutput(methodName, response.getReturnData());
BigInteger output = ((BigInteger) outputList.get(0));

# Get Node Status

Vitej vitej = new Vitej(new HttpService());
NetNodeInfoResponse response = vitej.netNodeInfo().send();
NetNodeInfoResponse.Result nodeInfo = response.getResult();

# Get Sync Status

Vitej vitej = new Vitej(new HttpService());
NetSyncInfoResponse response = vitej.netSyncInfo().send();
NetSyncInfoResponse.Result nodeInfo = response.getResult();

# Get Sync Detail

Vitej vitej = new Vitej(new HttpService());
NetSyncDetailResponse response = vitej.netSyncDetail().send();
NetSyncDetailResponse.Result nodeInfo = response.getResult();

# Call Raw RPC Method

Instead of calling a wrapped method as listed above, you can also call a raw RPC method. Below code shows an example of calling RPC method ledger_getAccountBlocksByAddress . For more information about raw RPC API, see RPC API Documentation.

Vitej vitej = new Vitej(new HttpService());
CommonResponse response = vitej.commonMethod("ledger_getAccountBlocksByAddress", "vite_ab24ef68b84e642c0ddca06beec81c9acb1977bbd7da27a87a",0,10).send();
Object result = response.getResult();