ETH开发 JSONRPC

最新推荐文章于 2024-05-25 09:45:50 发布
置顶 最新推荐文章于 2024-05-25 09:45:50 发布
阅读量712 收藏
点赞数
分类专栏： ETH
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43638275/article/details/101519917
版权

因为时间的原因，暂时没有对异常信息记性整理


package com.bib.wallet.utils;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * JSONRPC 方法抽象
 *
 * @author 小呆呆
 * @create 2019-08-29 11:49
 **/
@Service
public class JsonRPC {

    private static final Integer ID = 1;

    private static final String JSONRPC = "2.0";
    private static final String LATEST = "latest";
    private static final String PENDING = "pending";

    private static final String PERSONAL_NEW_ACCOUNT = "personal_newAccount";
    private static final String ETH_ACCOUNTS = "eth_accounts";
    private static final String ETH_GETBALANCE = "eth_getBalance";
    private static final String PERSONAL_UNLOCK_ACCOUNT = "personal_unlockAccount";
    private static final String ETH_SEND_TRANSACTION = "eth_sendTransaction";
    private static final String ETH_GET_TRANSACTION_COUNT = "eth_getTransactionCount";
    private static final String ETH_SING_TRANSACTION = "eth_signTransaction";
    private static final String ETH_SEND_RAW_TRANSACTION = "eth_sendRawTransaction";
    private static final String ETH_ESTIMATE_GAS = "eth_estimateGas";
    private static final String ETH_GAS_PRICE = "eth_gasPrice";
    private static final String ETH_PENDING_TRANSACTIONS = "eth_pendingTransactions";
    private static final String ETH_BLOCK_NUMBER = "eth_blockNumber";
    private static final String ETH_GET_BLOCK_NUMBER = "eth_getBlockByNumber";
    private static final String ETH_CALL = "eth_call";

    // private static final String http_host = "http://47.56.160.110:8719";
    private static final String http_host = "http://127.0.0.1:8719";
    private static final String PASSWORD = "123456";

    /**
     * 获取所有的账户
     * @return
     */
    public static JSONArray getEthAccounts(){
        Map<String,Object> map = new HashMap<>();
        map.put("jsonrpc",JSONRPC);
        map.put("method",ETH_ACCOUNTS);
        map.put("id",ID);
        map.put("params",new ArrayList<String>());
        String postWithjson =null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null) {
            return null; // 调用接口失败
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);

        //JSONArray result = jsonObject.getJSONArray("result");
        return jsonObject.getJSONArray("result");
    }

    /**
     * 获取账户余额
     * @param address  钱包地址
     * @return
     */
    public static String getBalance(String address){
        Map<String,Object> map = new HashMap<>();
        map.put("jsonrpc",JSONRPC);
        map.put("method",ETH_GETBALANCE);
        map.put("id",ID);
        List<String> list = new ArrayList<>();
        list.add(address);
        list.add(LATEST);
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null){ // 访问失败
            return postWithjson;
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){  // 地址不存在
            return null;
        }
        return jsonObject.get("result").toString();
    }

    /**
     * 创建一个新的账户
     * @return
     */
    public static String createNewAccount(){
        Map<String,Object> map = new HashMap<>();
        map.put("jsonrpc",JSONRPC);
        map.put("method",PERSONAL_NEW_ACCOUNT);
        map.put("id",ID);
        List<String> list = new ArrayList<>();
        list.add(PASSWORD);
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null){ // 访问失败
            return postWithjson;
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){  // 生成地址失败
            return null;
        }
        return jsonObject.get("result").toString();
    }

    /**
     * 解锁制定的账户
     * @param address 钱包地址
     * @param time  解锁时间 s
     * @return boolean
     */
    public static Boolean personUnlockAccount(String address, Long time){
        Map<String,Object> map = new HashMap<>();
        map.put("jsonrpc",JSONRPC);
        map.put("method",PERSONAL_UNLOCK_ACCOUNT);
        map.put("id",ID);
        List<Object> list = new ArrayList<>();
        list.add(address);
        list.add(PASSWORD);
        list.add(time);
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null){
            System.out.printf("1");
            return false;  // 解锁用户信息失败
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){
            System.err.println(jsonObject.get("error"));
            System.out.printf("2");
            return false; // 用户信息错误
        }
        return jsonObject.getBoolean("result");
    }

    /**
     * 直接交易的接口
     * @param from
     * @param to
     * @param gas
     * @param gasPrice
     * @param value
     * @param data
     * @return 返回交易hash
     */
    public static String ethSendTransaction(String from, String to, String gas, String gasPrice, String value, String data){
        Map<String,Object> map = new HashMap<>();
        map.put("jsonrpc",JSONRPC);
        map.put("id",ID);
        map.put("method",ETH_SEND_TRANSACTION);
        List<Map<String,String>> list = new ArrayList<>();
        Map<String,String> params = new HashMap<>();
        params.put("from",from);
        params.put("to",to);
        params.put("gas",gas);
        params.put("gasPrice",gasPrice);
        params.put("value",value);  // todo  ETH填金额  ERC 20 可以 不填
        params.put("data",data);
        list.add(params);
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null){
            return "1"; // 交易异常，请重新交易
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){
            System.err.println(jsonObject.get("error"));
            return "2"; // 交易失败  具体原因另看
        }

        return jsonObject.get("result").toString(); // 返回交易hash
    }
    /**
     * todo 热钱包不需要设置
     * 直接交易的接口
     * @param from
     * @param to
     * @param gas
     * @param gasPrice
     * @param value
     * @param data
     * @return 返回交易hash
     */
    public static String ethSendTransaction1(String from, String to,  String value, String data){
        Map<String,Object> map = new HashMap<>();
        map.put("jsonrpc",JSONRPC);
        map.put("id",ID);
        map.put("method",ETH_SEND_TRANSACTION);
        List<Map<String,String>> list = new ArrayList<>();
        Map<String,String> params = new HashMap<>();
        params.put("from",from);
        params.put("to",to);
        params.put("value",value);  // todo  ETH填金额  ERC 20 可以 不填
        params.put("data",data);
        list.add(params);
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null){
            return "1"; // 交易异常，请重新交易
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){
            System.err.println(jsonObject.get("error"));
            return "2"; // 交易失败  具体原因另看
        }

        return jsonObject.get("result").toString(); // 返回交易hash
    }

    /**
     * 查询地址发送交易的数量，下次交易的nonce从这个开始
     * @param address
     * @return 返回交易的数量
     */
    public static String ethGetTransactionCount(String address){
        Map<String,Object> map = new HashMap<>();
        map.put("method",ETH_GET_TRANSACTION_COUNT);
        map.put("id",ID);
        List<String> list = new ArrayList<>();
        list.add(address);
        list.add(PENDING);
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null){
            return "1"; // 获取 nonce 出现异常
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){
            System.err.println(jsonObject.get("error"));
            return "2"; // 参数有误
        }
        return jsonObject.get("result").toString();
    }

    /**
     * 构建原始交易，返回原始交易的签名 ETH
     * @param from
     * @param to
     * @param gas
     * @param gasPrice
     * @param value
     * @param data
     * @param nonce
     * @return 从冷钱包到热钱包的hash
     */
    public static String ethSignTranscation(String from, String to, String gas, String gasPrice, String value, String data, String nonce){
        Map<String,Object> map = new HashMap<>();
        map.put("method",ETH_SING_TRANSACTION);
        map.put("jsonrpc",JSONRPC);
        map.put("id",ID);
        List<Map<String,String>> list = new ArrayList<>();
        Map<String,String> params = new HashMap<>();
        params.put("from",from);
        params.put("to",to);
        params.put("gas",gas);
        params.put("gasPrice",gasPrice);
        params.put("value",value);
        params.put("data",data);
        params.put("nonce",nonce);
        list.add(params);
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null){
            return "1"; // 构建原始交易异常，请重试
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){
            System.err.println(jsonObject.get("error"));

            return "2"; // 构建原始交易失败，具体未整理
        }
        return JSONObject.parseObject(String.valueOf(jsonObject.getJSONObject("result"))).getString("raw");
    }

    /**
     * 构建原始交易，返回原始交易的签名 合约地址
     * @param from
     * @param to
     * @param gas
     * @param gasPrice
     * @param value
     * @param data
     * @param nonce
     * @return 从冷钱包到热钱包的hash
     * todo to
     */
    // todo  这个接口重新改一遍
    public static String ethSignTranscationContract(String from, String to, String gas, String gasPrice, String value, String data, String nonce){
        Map<String,Object> map = new HashMap<>();
        map.put("method",ETH_SING_TRANSACTION);
        map.put("jsonrpc",JSONRPC);
        map.put("id",ID);
        List<Map<String,String>> list = new ArrayList<>();
        Map<String,String> params = new HashMap<>();
        params.put("from",from);
        params.put("to",to);
        params.put("gas",gas);
        params.put("gasPrice",gasPrice);
        params.put("value",value);
        params.put("data",data);
        params.put("nonce",nonce);
        list.add(params);
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null){
            return "1"; // 构建原始交易异常，请重试
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){
            System.err.println(jsonObject.get("error"));
            return "2"; // 构建原始交易失败，具体未整理
        }
        return JSONObject.parseObject(String.valueOf(jsonObject.getJSONObject("result"))).getString("raw");
    }

    /**
     * 广播交易(判断有没有错误的情况，如果有，则写入数据 库)
     * @param hash_code  离线签名 hash
     * @return  交易成功的 hash
     */
    public static String ethSendRawTransaction(String hash_code){
        Map<String,Object> map = new HashMap<>();
        map.put("method",ETH_SEND_RAW_TRANSACTION);
        map.put("jsonrpc",JSONRPC);
        map.put("id",ID);

        List<String> list = new ArrayList<>();
        list.add(hash_code);
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null){
            return "1"; // 广播交易异常，请重试
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){
            System.err.println(jsonObject.get("error"));
            return "2";  // 广播交易失败，请查看原因
        }
        return jsonObject.getString("result");
    }

    /**
     * 返回交易可能需要的 gas
     * @param from  发出的地址
     * @param to    接受的地址
     * @param gas   可不填
     * @param gasPrice  可不填
     * @param value 可不填
     * @param data  可不填写
     * @return
     */
    public static String ethEstimateGas(String from,String to,String gas,String gasPrice,String value,String data){
        Map<String,Object> map = new HashMap<>();
        map.put("jsonrpc",JSONRPC);
        map.put("id",ID);
        map.put("method",ETH_ESTIMATE_GAS);
        List<Map<String,String>> list = new ArrayList<>();
        Map<String,String> params = new HashMap<>();
        params.put("from",from);
        params.put("to",to);
        params.put("gas",gas);
        params.put("gasPrice",gasPrice);
        params.put("value",value);
        params.put("data",data);
        list.add(params);
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null){
            return "1"; // 获取gas异常，请重新获取
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){
            System.err.println(jsonObject.get("error"));
            return "2"; // 获取gas失败，请查询原因
        }
        return jsonObject.getString("result"); // 返回 可能需要的gas
    }

    /**
     * 返回挂起的事务列表。
     * @return  返回 list 表示代处理的事物
     */
    public static List<Object> eth_pendingTransactions(){
        Map<String,Object> map = new HashMap<>();
        map.put("jsonrpc",JSONRPC);
        map.put("id",ID);
        map.put("method",ETH_PENDING_TRANSACTIONS);
        List<String> list = new ArrayList<>();
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        List<Object> list1 = new ArrayList<>();
        if (postWithjson == null){
            list1.add("10001");
            return list1;
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){
            System.err.println(jsonObject.get("error"));
            list1.add("10002");
            return list1;
        }
        return jsonObject.getJSONArray("result");
    }
    // ETH_BLOCK_NUMBER

    /**
     * 获取当前区块的高度
     * @return
     */
    public static BigInteger ethBlockNumber(){
        Map<String,Object> map = new HashMap<>();
        map.put("jsonrpc",JSONRPC);
        map.put("id",ID);
        map.put("method",ETH_BLOCK_NUMBER);
        List<String> list = new ArrayList<>();
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        List<Object> list1 = new ArrayList<>();
        if (postWithjson == null){
            list1.add("10001");
            return new BigInteger("1");
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){
            System.err.println(jsonObject.get("error"));
            list1.add("10002");
            return new BigInteger("2");
        }
        System.err.println(jsonObject.getString("result"));
        return new BigInteger(Decimal.haxToBingInt(jsonObject.getString("result").substring(2)));
    }

    /**
     * 获取指定高度的交易信息
     * @param hax
     * @return
     */
    public static Object ethGetBlockByNumber(String hax){
        Map<String,Object> map = new HashMap<>();
        map.put("jsonrpc",JSONRPC);
        map.put("id",ID);
        map.put("method",ETH_GET_BLOCK_NUMBER);
        List<Object> list = new ArrayList<>();
        list.add(hax);
        list.add(true);
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null){
            return new BigInteger("1");
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){
            System.err.println(jsonObject.get("error"));
            return new BigInteger("2");
        }
        JSONObject result = jsonObject.getJSONObject("result");
        return result.getJSONArray("transactions");
    }

    /**
     * 获取ERC20的名字
     * @param contract
     * @return
     */
    public static String getERC20Name(String contract){
        Map<String,Object> map = new HashMap<>();
        map.put("jsonrpc",JSONRPC);
        map.put("id",ID);
        map.put("method",ETH_CALL);
        List<Object> list = new ArrayList<>();
        Map<String,Object> maps = new HashMap<>();
        maps.put("to",contract);
        maps.put("data","0x95d89b41000000000000000000000000");
        list.add(maps);
        list.add(LATEST);
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null){
            return "1";
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){
            System.err.println(jsonObject.get("error"));
            return "2";
        }
        return Decimal.hexStringToString(jsonObject.getString("result").substring(130).replace("0",""));
    }

    /**
     * 获取 ERC20 需要程序 10 次方 number
     * @param contract
     * @return
     */
    public static String getERC20Number(String contract){
        Map<String,Object> map = new HashMap<>();
        map.put("jsonrpc",JSONRPC);
        map.put("id",ID);
        map.put("method",ETH_CALL);
        List<Object> list = new ArrayList<>();
        Map<String,Object> maps = new HashMap<>();
        maps.put("to",contract);
        maps.put("data","0x313ce567000000000000000000000000");
        list.add(maps);
        list.add(LATEST);
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null){
            return "1";
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){
            System.err.println(jsonObject.get("error"));
            return "2";
        }
        System.err.println(jsonObject.getString("result").substring(2).replace("0",""));
        return Decimal.haxToBingInt(jsonObject.getString("result").substring(2).replace("0","").equals("") ? "0" : jsonObject.getString("result").substring(2).replace("0",""));
    }

    // ETH_GAS_PRICE

    public static String ethGasPrice(){

        Map<String,Object> map = new HashMap<>();
        map.put("jsonrpc",JSONRPC);
        map.put("id",ID);
        map.put("method",ETH_GAS_PRICE);
        List<Map<String,String>> list = new ArrayList<>();
        map.put("params",list);
        String postWithjson = null;
        try {
            postWithjson = HttpUtils.httpPostWithjson(http_host, new JSONObject(map).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (postWithjson == null){
            return "1"; // 获取gas异常，请重新获取
        }
        JSONObject jsonObject = JSONObject.parseObject(postWithjson);
        if (jsonObject.get("error") != null){
            System.err.println(jsonObject.get("error"));
            return "2"; // 获取gas失败，请查询原因
        }
        return jsonObject.getString("result"); // 返回 可能需要的gas
    }

}
weixin_43638275
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ethjsonrpc：以太坊区块链的Python JSON-RPC客户端
02-05
ethjsonrpc：以太坊区块链的Python JSON-RPC客户端
eth json rpc php,eth JSON-RPC接口
weixin_39867559的博客
03-20 388
总结一些当前项目中用到的eth JSON-RPC接口当前燃气价格{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":73}返回客户端拥有的地址列表 应该是账户地址{"jsonrpc":"2.0","method":"eth_accounts","params":[],"id":1}返回给定地址的帐户的余额 参数地址{"jsonrpc"...
Ethrpc：一款强大的以太坊JSON RPC API客户端库
最新发布
gitblog_00046的博客
05-25 312
Ethrpc：一款强大的以太坊JSON RPC API客户端库 项目地址:https://gitcode.com/onrik/ethrpc 项目介绍 Ethrpc 是一个用 Go 语言编写的轻量级库，它为开发人员提供了与以太坊区块链交互的便捷方式。通过封装以太坊的JSON RPC API，Ethrpc使得在Golang环境中进行智能合约调用、账户管理以及交易处理变得极其简单。 项目技术分析 Eth...
以太坊json rpc
J_Lee
12-02 607
Contents Hash List JSON-RPC support HEX value encoding The default block parameter Curl Examples Explained JSON-RPC methods Hash List 类型 长度 描述 blockHash String 0x+64位 区块的哈希 blockNumber Number 区块的块号 transactionHash String 0x+64位 交易的哈希值 tra
解析json rpc获得的ETH log信息
PancrasBohemian的博客
04-26 656
package main import ( "bytes" ct "contracts" "encoding/hex" "encoding/json" "fmt" "github.com/ethereum/go-ethereum/accounts/abi" "io/ioutil" "math/big" "net/http" "strings" ) func main() { // 略去一些信息 request, error := http.NewRequest("POST",
JSON-RPC API 调用以太坊客户端
稻草人的博客
04-27 1778
前言写次博客职位记录自己遇到的问题，建立在能够搭建Ethereum私有链或者测试网络，如有不懂自行百度教程正文一般在网上找到的打开私有链命令是geth --identity "PICCetherum" --rpc --rpccorsdomain "*" --datadir "%cd%\chain" --port "30303"  --rpcapi "db,eth,net,web3" --netwo...
ethereumex：以太坊区块链的Elixir JSON-RPC客户端
02-05
JSON-RPC（JSON Remote Procedure Call）是一种轻量级的远程过程调用协议，使用JSON作为数据交换格式。Ethereumex使得Elixir开发者能够轻松地查询区块信息、交易详情、账户余额，以及执行智能合约等操作。 **...
web3-以太坊JSON-RPC客户端-Rust开发
05-27
rust-web3以太坊JSON-RPC多传输客户端。 Web3.js库的Rust实现。 文档用法首先，将其添加到您的Cargo.toml中：[d rust-web3以太坊JSON-RPC多传输客户端。 Web3.js库的Rust实现。 文档用法首先，将其添加到Cargo.toml...
DAPP开发技术课件：Web3.js 基础与案例.pptx
05-18
Web3.js库封装了JSON-RPC API，使得开发者无需直接处理底层的RPC调用，从而更专注于应用逻辑的实现。 **Web3.js简介** Web3.js是基于JavaScript的以太坊开发库，它的主要功能是为开发者提供与以太坊节点的通信接口...
eth-utils:以太坊实用程序，开发工具，脚本等
05-13
eth-utils 以太坊实用程序，开发工具，脚本等 gethup.sh ：原始包装至 gethcluster.sh ：非交互式启动本地集群（ ） ...在端口81dd上启动json-rpc服务器（例如8100、8101、8102等） 多余的参数传递给了geth $
web3.js增加eth.getRawTransactionByHash(txhash)方法步骤
10-18
`eth_getRawTransactionByHash` 是一个 JSON-RPC 方法，用于根据交易哈希获取未编码的交易数据。在 Web3.js 中，这个功能默认可能并未直接暴露，因此我们需要手动添加此方法到库中。以下是详细的步骤： 1. 首先，你...
ethrpc：以太坊json rpc api的Golang客户端
02-05
道德 以太坊Golang客户端。 web3_clientVersion web3_sha3 net_version net_peerCount net_listening eth_protocolVersion eth_syncing eth_coinbase eth_mining eth_hashrate eth_gas价格 eth_accounts eth_blockNumber eth_getBalance eth_getStorageAt eth_getTransactionCount eth_getBlockTransactionCountByHa
eth-client：一个Golang客户端库，用于与以太坊RPC服务器通信
02-05
道德客户 一个与Ethereum RPC服务器通信的Golang客户端库。 实现大多数JSON-RPC方法和几种特定于客户端的方法。 提供高级界面以在伊斯坦布尔区块链上提议/获取验证器。 提供高级接口以在Quorum区块链上创建私人合同。 用法 package main import ( "context" "fmt" "github.com/getamis/eth-client/client" ) func main () { url := "http://127.0.0.1:8545" client , err := client . Dial ( url ) if e
ethereum安装+搭建eth的json-rpc
weixin_41997115的博客
09-22 299
sudo add-apt-repository -y ppa:ethereum/ethereum sudo apt-get update sudo apt-get install ethereum 启动jsonrpc nohup geth --syncmode "fast" --port "30303" --cache=4096 --datadir /data/eth/ethdata --rpc --rpcapi eth,personal --rpcport 8931 --rpcaddr 0.0.0.0
ethereum rpc
weixin_44830725的博客
07-13 3299
以太坊rpc
Ethereum JSON-RPC
781193278专栏
11-29 5752
1 Ethereum RPC APIs 1) Standard APIs 2) Geth Specific APIs 2 Ethereum RPC 1) HTTP-RPC：手动启动 --rpc --rpcaddr --rpcport --rpcapi --rpccorsdomain 2) WS-RPC：手动启动 --ws --wsaddr --wsport -
第03课：以太坊常见 JSON-RPC 接口解析
Forrest Gump · 技术宅
04-26 8762
第03课：以太坊常见 JSON-RPC 接口解析以太坊提供了一套基于 JSON-RPC 的接口调用，通过这些接口调用我们可以方便的进行相关的查询、挖矿、发起交易等操作。今天带大家了解一下比较常见的一些 JSON-RPC 接口。什么是 JSON-RPCJSON RPC（Remote Protocol Call）是一种以 JSON 为协议的远程调用服务，具有开发调试简单、多平台通用的特性。很明显是通过...
java https jasonrpc_以太坊 ethereum JSON-RPC java 调用示例
weixin_28899845的博客
02-24 260
启动 geth在启动时需要开启 rpc 的支持：geth --identity "ethtest" --rpc --rpcaddr 10.200.123.19 --port 10071 --rpcport 10070 --rpcapi "personal,db,eth,net,web3" --datadir /data/ethdata --nodiscover --networkid 666_ r...
ETH002双串口服务器配置与功能详解
"ETH002是一款工业级的双串口服务器模块，设计用于将串行设备连接到网络，提供透明传输和稳定的联网功能。它支持10/100M网络接口，具有宽电压（9-36V）供电系统，功耗低，适合各种恶劣环境。该模块具备以下特性： 1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值